Saravanan666/pypi-org huggingface dataset:
Package: depository
depositoryThis repository provides tooling and workflow recommendations for storing, scheduling, and publishing notebooks.Automatic Notebook VersioningEvery save of a notebook creates an immutable copy of the notebook on object storage.To ease implementation, we'll rely on S3 as the object store, usingversioned buckets.Storage PathsAll notebooks are archived to a single versioned S3 bucket with specific prefixes denoting the lifecycle of the notebook:/workspace- where users edit/scheduled- notebooks currently scheduled/published- public notebooks (to an organization)Each notebook path is a namespace that an external service ties into the schedule. We archive off versions, keeping the path intact (until a user changes them).PrefixIntent/workspace/kylek/notebooks/mine.ipynbNotebook in “draft”/scheduled/kylek/notebooks/mine.ipynbCurrent scheduled copy/published/kylek/notebooks/mine.ipynbCurrent published copyTransitioning to this Storage PlanSince most people are on a regular filesystem, we'll start with writing to the/workspaceprefix as Archival Storage (writing on save using apost_save_hookfor a Jupyter contents manager).ConfigurationfromdepositoryimportdepositoryContentsArchiver# jupyter config# At ~/.jupyter/jupyter_notebook_config.py for user installs# At __ for system installsc=get_config()c.NotebookApp.contents_manager_class=depositoryContentsArchiverc.depository.workspace_prefix="/workspace/kylek/notebooks"c.depository.published_prefix="/published/kylek/notebooks"c.depository.scheduled_prefix="/scheduled/kylek/notebooks"# Optional, in case you're using a different contents manager# This defaults to notebook.services.contents.manager.ContentsManager# c.depository.Archiver.underlying_contents_manager_class = ADifferentContentsManagerc.depository.Backend="s3"c.depository.S3.bucket="<bucket-name>"# Note: if depository is used from an EC2 instance with the right IAM role, you don't# have to specify thesec.depository.S3.access_key_id=<AWSAccessKeyID/IAMAccessKeyID>c.depository.S3.secret_access_key=<AWSSecretAccessKey/IAMSecretAccessKey>
Package: depot
Used to push, it is a replacement for reprepro+s3cmd sync and whatnot.It does incremental updates of a repo, so you don’t need to keep a full local copy of the repo anymore.You just feed it each package as they are made and it updates all the various metadata files as needed.UsageUsage: depot [options] <package> [<package> ...]

-h --help                    show this help message and exit
--version                    show program's version number and exit
-s URI --storage=URI         URI for storage provider, checks $DEPOT_STORAGE or local://
-c NAME --codename=NAME      Debian distribution codename [default: lucid]
--component=NAME             Debian component name [default: main]
-a ARCH --architecture=ARCH  package architecture if not specified in package
-k KEYID --gpg-key=KEYID     GPG key ID to use for signing
--no-sign                    do not sign this upload
--no-public                  do not make cloud files public-readableExampledepot -s s3://apt.example.com -c precise -k 6791B14F mypackage.debStorage LocationStorage locations are given as URIs like local:///srv/repo or s3://key:secret@bucket. Any scheme supported
by libcloud should work, but only local and s3 have been tested so far.S3 CredentialsYou can pass your AWS access key ID and secret access key as the username and password in the storage URI,
or if not present depot will check the $AWS_ACCESS_KEY_ID and $AWS_SECRET_ACCESS_KEY environment variables.
Package: depot-pm
# depot-pma pacakge manager helps you to install packages from multiple package managers quickly## Installation```shellpip install -U depot-pm```## Usage* check version```shelldepot-pm version```* install packages```bashdepot-pm install [package-file]```By default, depot-pm will find ```depot.yaml``` or ```depot.json``` from current working directory.if depot-pm could not find these config files at currnet working directory, it will find in upper directoryuntil it reaches ```/```.## Congif file (depoy.yaml)Check the sample file in source root (depot.yaml)### PackagesIt should contains at least one section: ```pacakges```. The packages section is a dictionary whichuses **installer name** as its key and **packages ot be installed** as value. (a list). So if you want touse ```pip``` to install ```django 1.7``` and ```boto```, you should type:```yamlpackages:pip:- django==1.7- boto```So the sample file (depoy.yaml) will produce following commands on OS X (which uses ```brew``` but not ```yum```):```shellwhich python3 1>/dev/null 2>&1 || brew install python3brew install youtube-dlpip install taskr botogem install cocoapodsnpm install -g less```Note that it will check whether python3 exists or not before installing python 3.and following on CentOS (uses ```yum```):```shellsudo yum install -y wgetpip install taskr botogem install cocoapodsnpm install -g less```The format of package name could be any acceptable form of each installers.### InstallersThe ```installers``` section defines an installer. Installer configurations has following keys:Key | Description | Default Value----|-------------|---------------sudo | boolean flag indicating wheather this installer should run with sudo command   | Falseos | boolean flag indicating this installer is an OS specific installer which be run before other installers. (non OS specific ones) | Falsemultiple | the installer could install multiple packages at ones | Truesyntax | the template to generate command. Use [python's string format syntax](https://docs.python.org/3/library/string.html#formatspec) | {} install {}command | the command name of this installer | {INSTALLER_NAME}Currenty we have:Installers | Config-----------|--------pip        | {DEFAULT}pip3       | {DEFAULT}gem        | {DEFAULT}npm        | {DEFAULT} but ```syntax``` is ```{} install -g {}```brew       | {DEFAULE} but ```os``` is changed to ```true```yum        | {DEFAULE} but ```os``` and ```sudo``` are changed to ```true```. ```syntax``` is ```{} install -y {}```## ContactUse the issue tracker to contact me :smile:## TODO* check package.json, requirements.txt, and other package file support.
Package: depoverflow
DepoverflowThis tool checks your source code for references to Stackoverflow answers and GitHub issues and warns you if those change.Why?There are plenty of tools that will let you know if your package dependencies have changed (poetry show -o,npm outdated, ...). There are even cloud-based services like Dependabot.However, if you copy/paste code from Stackoverflow answers or GitHub issues, you will never be notified of updates.FeaturesFind references to Stackoverflow answers and questions in code comments, to alert of edits and/or commentsFind references to GitHub issues in code comments, to alert of open and close events and/or commentsOptionally supports specific keywords such as "Works around"Saves current status of referenced items in a TOML file (similar to a lockfile), that you can check into version control (or not)How to useInstall the tool:pip install depoverflowCreate a configuration filedepoverflow.tomlwith the list of source file patterns you want to read (inPython glob format):sources=["src/**.py","tests.py","native/*.c",]Run the tool:depoverflow.A filedepoverflow.statuswill be created, which you can check into version control or not. It is a TOML file containing the current status of the items you reference from your code, so that a warning can be shown the next time they change.
Package: deprecate-cmsplugin-filer
deprecate_cmsplugin_filerA small app with a migration for converting deprecated cmsplugin-filer objects to djangocms plugin objects. Adapted fromhttps://gist.github.com/wfehr/86ac31e8e263b872b746cc721662251eto add link and video plugin capability.Things you'll want to evaluate before migrating:Whether any custom project-level templates are in use for the cmsplugin filer modules. Any special customizations may need to be re-implemented in the djangocms-[file/link/picture/video] templates.If you currently are using django config settings such as CMSPLUGIN_FILER_IMAGE_STYLE_CHOICES or FILER_LINK_STYLES, you'll need to copy these as DJANGOCMS_PICTURE_TEMPLATES and DJANGOCMS_LINK_TEMPLATES, respectively. Note: there is a difference in behavior with FILER_LINK_STYLES and DJANGOCMS_LINK_TEMPLATES. The former would simply set a class while the latter expects a corresponding template to be created. Reference:https://github.com/divio/djangocms-link/#configurationMigration steps:Before running the migration, you can run the following command to make sure you back up the old plugin tables for quick restoring if needed.
./manage.py dumpdata cmsplugin_filer_file cmsplugin_filer_folder cmsplugin_filer_image cmsplugin_filer_link cmsplugin_filer_video > ~/cmsplugin_filer.jsonEnsure you've installed the new plugins, added them to INSTALLED_APPS, and migrated:
pip install djangocms-file djangocms-link djangocms-picture djangocms-video
INSTALLED_APPS += (
'djangocms_file',
'djangocms_link',
'djangocms_picture',
'djangocms_video',
)
./manage.py migrateI recommend also running the following command before and after the migration to get an inventory of the site's plugins and ensure they've all been migrated.
./manage.py cms list pluginsNow the small app with the migration can be installed and run:
./manage.py migrate deprecate_cmsplugin_filerIf you once again run ./manage.py cms list plugins, you should see the cmsplugin-filer objects have been converted to djangocms-[file/link/picture/video] objects.Do a spotcheck of plugins on the site. This is where you may see errors related to previous FILER_LINK_STYLES that are now expecting corresponding templates to be created for each style.
Package: deprecate-kwargs
deprecate-kwargsA Tool for Deprecating (Keyword) Arguments for Backward Compatibility for Python Functions.A decorator is implemented to deprecate old kwargs in a function, with signature and docstring modified accordingly.
Instead of replacing the old kwargs with new ones, this decorator makes old and new kwargs both available,
with warnings raised when old kwargs are passed.deprecate-kwargsInstallationUsage ExampleBenefitsInstallationRunpython-mpipinstalldeprecate-kwargsor install the latest version inGitHubusingpython-mpipinstallgit+https://github.com/DeepPSP/deprecate-kwargs.gitUsage Example>>>fromdeprecate_kwargsimportdeprecate_kwargs>>>@deprecate_kwargs([["new_arg_1","old_arg_1"],["new_arg_2","old_arg_2"],["new_kw","old_kw"]])>>>defsome_func(old_arg_1:int,old_arg_2:int,old_kw:int=3):>>>return(old_arg_1+old_arg_2)*old_kw>>>some_func.__signature__<Signature(new_arg_1:int,new_arg_2:int,new_kw:int=3)>>>>some_func(10,20,3)90>>>some_func(new_arg_1=10,new_arg_2=20,new_kw=3)90>>>some_func(10,old_arg_2=20,old_kw=3)PendingDeprecationWarning:(keyword)argument"old_arg_2"isdeprecated,use"new_arg_2"insteadPendingDeprecationWarning:(keyword)argument"old_kw"isdeprecated,use"new_kw"instead90Benefitsdeprecate_kwargsis quite useful when one wants to change the name of an argument (or keyword argument) of some function, while keeping old codes using this function still working, hence is beneficial for backward compatibility. For example, say in version 0.1 of some package, there's a functiondefsome_deep_learning_model_trainer(learning_rate,...):...And in version 0.2, someone wants to changelearning_ratetolr. If it was replaced directly viadefsome_deep_learning_model_trainer(lr,...):...then old codes using this function bycallingsome_deep_learning_model_trainer(learning_rate=1e-3, ...)would break. However, if the replacement is done using@deprecate_kwargs([["lr","learning_rate"]])defsome_deep_learning_model_trainer(learning_rate,...):...then one can call this function usingsome_deep_learning_model_trainer(lr=1e-3), as well assome_deep_learning_model_trainer(learning_rate=1e-3, ...)only with a warning raised. In this way, old codes are rescued from breaking.
Package: deprecation
deprecationThedeprecationlibrary provides adeprecateddecorator and afail_if_not_removeddecorator for your tests. Together, the two
enable the automation of several things:The docstring of a deprecated method gets the deprecation details
appended to the end of it. If you generate your API docs direct
from your source, you don’t need to worry about writing your own
notification. You also don’t need to worry about forgetting to
write it. It’s done for you.Rather than having code live on forever because you only deprecated
it but never actually moved on from it, you can have your tests
tell you when it’s time to remove the code. The@deprecateddecorator can be told when it’s time to entirely remove the code,
which causes@fail_if_not_removedto raise anAssertionError,
causing either your unittest or py.test tests to fail.Seehttp://deprecation.readthedocs.io/for the full documentation.Installationpip install deprecationUsageimport deprecation

@deprecation.deprecated(deprecated_in="1.0", removed_in="2.0",
                        current_version=__version__,
                        details="Use the bar function instead")
def foo():
    """Do some stuff"""
    return 1…but doesn’t Python ignoreDeprecationWarning?Yes, by default since 2.7—and for good reason[1]—and this works fine
with that.It often makes sense for you to run your tests with a-Wflag or
thePYTHONWARNINGSenvironment variable so you catch warnings
in development and handle them appropriately. The warnings raised by
this library show up there, as they’re subclasses of the built-inDeprecationWarning. See theCommand LineandEnvironment Variabledocumentation for more details.Even if you don’t enable those things, the behavior of this library
remains the same. The docstrings will still be updated and the tests
will still fail when they need to. You’ll get the benefits regardless
of what Python cares aboutDeprecationWarning.[1]Exposing application users toDeprecationWarnings that are
emitted by lower-level code needlessly involves end-users in
“how things are done.” It often leads to users raising issues
about warnings they’re presented, which on one hand is done
rightfully so, as it’s been presented to them as some sort of
issue to resolve. However, at the same time, the warning could
be well known and planned for. From either side, loudDeprecationWarnings can be seen as noise that isn’t
necessary outside of development.
Package: deprecation-alias
A wrapper around ‘deprecation’ providing support for deprecated aliases.TestsPyPIAnacondaActivityQAOtherInstallationdeprecation-aliascan be installed from PyPI or Anaconda.To install withpip:$python-mpipinstalldeprecation-aliasTo install withconda:First add the required channels$condaconfig--addchannelshttps://conda.anaconda.org/conda-forge$condaconfig--addchannelshttps://conda.anaconda.org/domdfcodingThen install$condainstalldeprecation-alias
Package: deprempy
deprempyKandilli Rasathanesi araciligi ile elde edilen deprem sinyallerini kullanarak depremleri gosteren bir Python kutuphanesidir.InstallationUse the package managerpipto install foobar.pipinstall-UdeprempyUsagefromdeprempyimportDepremdeprem=Deprem()deprem.son_deprem()"""{'tarih': '2023.04.19','saat': '14:45:23','enlem': '37.8543','boylam': '36.5763','derinlik': '12.1','buyukluk': '2.5','yer': 'CEVREPINAR-(KAHRAMANMARAS)','tip': 'Ilksel'}"""deprem.son_1saat(2)"""[{'tarih': '2023.04.19','saat': '14:45:23','enlem': '37.8543','boylam': '36.5763','derinlik': '12.1','buyukluk': '2.5','yer': 'CEVREPINAR-(KAHRAMANMARAS)','tip': 'Ilksel'},{'tarih': '2023.04.19','saat': '14:28:29','enlem': '37.4822','boylam': '35.2963','derinlik': '7.7','buyukluk': '2.0','yer': 'MADENLI-ALADAG (ADANA)','tip': 'Ilksel'}]"""deprem.son_24saat(2)"""[{'tarih': '2023.04.19','saat': '14:45:23','enlem': '37.8543','boylam': '36.5763','derinlik': '12.1','buyukluk': '2.5','yer': 'CEVREPINAR-(KAHRAMANMARAS)','tip': 'Ilksel'},{'tarih': '2023.04.19','saat': '14:28:29','enlem': '37.4822','boylam': '35.2963','derinlik': '7.7','buyukluk': '2.0','yer': 'MADENLI-ALADAG (ADANA)','tip': 'Ilksel'}]"""deprem.tum_depremler(2)"""[{'tarih': '2023.04.19','saat': '14:45:23','enlem': '37.8543','boylam': '36.5763','derinlik': '12.1','buyukluk': '2.5','yer': 'CEVREPINAR-(KAHRAMANMARAS)','tip': 'Ilksel'},{'tarih': '2023.04.19','saat': '14:28:29','enlem': '37.4822','boylam': '35.2963','derinlik': '7.7','buyukluk': '2.0','yer': 'MADENLI-ALADAG (ADANA)','tip': 'Ilksel'}]"""LicenseMITContactTelegram-Github
Package: depro
deproa package for Decomposition profile data analysis to grasp the effects of small compounds.Dependencypython 3.6requirements: numpy, pandas, scipy, tqdm, enanSetuppip install deprofor conda environment, please use skeletonUsagesee samplecode.ipynbLicenceThis software is released under the MIT License.AuthorsMIZUNO TadahayaReferencesThis package is inspired from the following brilliant databases and studies:Nat Genet. 2003 Jul;34(3):267-73.PNAS. October 25, 2005 102 (43) 15545-15550.BMC Bioinformatics. 2013;128(14).Enrichr: a comprehensive gene set enrichment analysis web server 2016 update. Nucleic Acids Research. 2016; gkw377 .Science. 2006 Sep 29;313(5795):1929-35.MsigDBEnrichRCMapAlso our results:Development of Orthogonal Linear Separation Analysis (OLSA) to Decompose Drug Effects into Basic Components. Mizuno T, Kinoshita S, Ito T, Maedera S, Kusuhara H., Sci Rep. 2019 Feb 12;9(1):1824. doi: 10.1038/s41598-019-38528-4.Bug ReportIf you would like to report any bugs about this package, don't hesitate to create an issue on github here, or email me:tadahaya@gmail.comtadahaya@mol.f.u-tokyo.ac.jptadahaya@g.ecc.u-tokyo.ac.jpTo Doprepare sample code
Package: deproulette
Mama always said life was like a box of chocolates. You never know what you’re gonna get.—Forrest Gump, 1994Do you ever get tired of knowing what you get? Have you ever felt you needed
to spice up your deployments?With deproulette, you get what you wish for approximately none of the times.
This imprecision is achieved through “creative” use of the python package
distribution framework.UsageThink of one or more packages, no need for unique packages,
but at most 5 packages, then runpipinstalldeprouletteOnce this has run, you have probably installed something else than what you
were thinking of. If not: please shoot me an email.How does it work?To achieve maximum discomfort for its users, deproulette downloads a list of
packages fromhttps://pypi.python.org/simple/, then selects a random amount
of packages a random amount of times.For all the details,
seehttps://github.com/joar/deproulette/blob/master/setup.py.
Package: depscanner
DepScannerPython Dependency Scanner is A simple dependency analysis kit>>>fromdepscannerimportDependencyScanner>>>t=DependencyScanner()>>>project_result=t.scan_project()>>>pipenv_result=t.scan_pipenv()>>>Installing DepScanner and Supported VersionsDepScanner is available on PyPI:python-mpipinstalldepscannerDepScanner officially supports Python 3.6+.API Reference and User Guide available on Read the DocsDocumentation
Package: deps-helper
dependency helperDependency helper for properties of python class$ pip install deps_helperfromdeps_helperimportDependenciesclassA(deps:=Dependencies.new()):@deps.register(_for="operation")defrequested_by(self,user):print(f"operation requested by{user}.")returnf"requested by{user}"@deps.register(_for=["check_validity","operation"])defvalidity(*_):...@deps.guard()defoperation(self):print("execute operation...")@deps.guard()defcheck_validity(self):ifself.validity:print("Ok")>>>a=A()>>>a.check_validity()Traceback(mostrecentcalllast):...AttributeError:("follow attributes are not assigned for check_validity => ",[validity])>>>a.operation()Traceback(mostrecentcalllast):...AttributeError:("follow attributes are not assigned for operation => ",[requested_by,validity])>>>a.validity=True>>>a.check_validity()Ok>>>a.requested_by="admin"operationrequestedbyadmin.>>>a.operation()executeoperation...>>>print(a.requested_by)requestedbyadmin>>>
Package: depsolve
DepSolveThis is an asyncio agnostic dependency tree solverThe idea is to take out the problem of depencies solving from packages managers or importersUsageimportasynciofromdepsolveimportDependency,walkasyncdefperform_importation(dependency:Dependency):# here your package/whatever is supposed to inherit from `Dependency`# if any other argument is need for the command line in the package# have a look to functools.partial()awaitasyncio.sleep(2)asyncdefmain():dependencies=[Dependency(name='land'),Dependency(name='hen',depends_on=['land']),Dependency(name='eggs',depends_on=['hen']),Dependency(name='sugar_cane',depends_on=['land']),Dependency(name='plain flour',depends_on=['wheat']),Dependency(name='sugar',depends_on=['sugar_cane']),Dependency(name='genoise',depends_on=['eggs','sugar']),Dependency(name='strawberry',depends_on=['land']),Dependency(name='wheat',depends_on=['land']),Dependency(name='sirop',depends_on=['strawberry']),Dependency(name='cake',depends_on=['genoise','strawberry','sirop']),Dependency(name='cooking',depends_on=['cake'])]foritemsinwalk(dependencies):deps_names=[dep.namefordepinitems]print(f'dependencies to install:{len(items)}:{", ".join(deps_names)}')tasks=asyncio.gather(*[perform_importation(dep)fordepinitems])awaittasksif__name__=="__main__":asyncio.run(main())wich output:dependencies to install: 1 : land
dependencies to install: 4 : hen, sugar_cane, strawberry, wheat
dependencies to install: 4 : eggs, plain flour, sugar, sirop
dependencies to install: 1 : genoise
dependencies to install: 1 : cake
dependencies to install: 1 : cooking
Package: depthai-gui
Gen2 Visual Pipeline EditorThis experiment has two components:A visual graph editor that lets you compose a DepthAI pipeline visually and save it as a JSON file.A parser for those JSON files that will turn it into a usable DepthAI pipelineEditorThe graph editor is a modified version ofNodeGraphQtby Johnny Chan.InstallationTo install this tool, run the following command$ python3 -m pip install depthai-guiUsageTo run thevisual pipeline editor, run the following command$ depthai-guiNavigationPressTabto create new nodesRight ClickTo save/load pipeline graphsYou can find a full list of controls in theNodeGraphQt DocumentationYou can also provide optional arguments, like default context path (-p / --path) or the project file to open (-o / --open)$ depthai-gui --help
usage: depthai-gui [-h] [-p PATH] [-o OPEN]

optional arguments:
  -h, --help            show this help message and exit
  -p PATH, --path PATH  Path to save/load default directory
  -o OPEN, --open OPEN  Path to project file to openAlso, you can use thedemo programthat will run the generated pipeline (or defaultExampleGraph.json) with the following command$ depthai-gui-demo  # to run a default ExampleGraph.json
$ depthai-gui-demo -p <path>  # to run a custom pipelineLocal developmentIf you want to enhance or modify this script or would like to install it without PyPi, please install all the necessary requirements with$ python3 install_requirements.pyNext, you can check the following files:pipeline_editor.py- Runs the visual pipeline editor (eqivalent ofdepthai-gui)demo.py- Runs the demo script (equivalent ofdepthai-gui-demo)DAIPipelineGraph.pyis the graph parser.Using exported pipelineIf you want to use the generated pipeline in your application, you can do so by importingDAIPipelineGraphmodule.And example integration is shown belowfrom DAIPipelineGraph import DAIPipelineGraph

pipeline_graph = DAIPipelineGraph( path=pipeline_path )

with dai.Device( pipeline_graph.pipeline ) as device:
  ...The most useful fields you can use fromDAIPipelineGraphclass are:DAIPipelineGraph.pipeline: A reference to the DepthAI pipelineDAIPipelineGraph.nodes: A table of all the nodes. You can access them via the name you put into the "Node Name" field in the editor. Ex:pipeline_graph.nodes["rgb_cam"].setPreviewSize(300,300)DAIPipelineGraph.xout_streams: A list of all the names of the XLinkOut streamsYou can also checkthe demo scriptas a reference on how to make a working scripts with this class