Saravanan666/pypi-org huggingface dataset:
Package: deux-q5
Version:1.2.0Web:https://deux.readthedocs.org/Download:https://pypi.python.org/pypi/deuxSource:https://github.com/robinhood/deuxKeywords:authentication, two-factor, multifactorAboutMultifactor Authentication provides multifactor authentication integration for
the Django Rest Framework. It integrates with Token Authentication built into
DRF and OAuth2 provided bydjango-oauth-toolkit.What is Multifactor Authentication?Multifactor Authentication (MFA) is a security system that requires more than
one method of authentication from independent categories of credentials to
verify the user’s identity for a login or other transaction.
(Source:SearchSecurity)InstallationYou can install deux either via the Python Package Index (PyPI)
or from source.Requirementsdeuxversion 1.2.0 runs on Python (2.7, 3.4, 3.5).Installing with pipTo install usingpip:$ pip install -U deuxDownloading and installing from sourceDownload the latest version of deux fromhttp://pypi.python.org/pypi/deuxYou can install it by doing the following:$ tar xvfz deux-0.0.0.tar.gz
$ cd deux-0.0.0
$ python setup.py build
# python setup.py installThe last command must be executed as a privileged user if
you are not currently using a virtualenv.Using the development versionWith pipYou can install it by doing the following:$ pip install https://github.com/robinhood/deux/zipball/master#egg=deux
Package: devaa
DevaaAndrea Nicoletta - 2022Documentation onGitHubTable of Contents:Analysis1.1.Eccentricity1.2.Centrality Measures1.3.Small World Property1.4.Friendship Paradox1.5.Degree Distribution1.6.Clustering Coefficient1.7.Assortativity1.8.Bridges1.9.RobustnessCommunity DetectionDynamics3.1.SEIS Model3.2.Threshold Model3.3.Algorithmic Bias Model3.4.Dynamics and Communities3.4.1.Threshold Model3.4.2.Independent CascadesRandom ModelsAppendix: GEMSECEnd
Package: dev-aa-test-1
HyFiveWhat Is HyFive?HyFive is aHylibrary that provides a Lispy functional interface by wrapping Python's popular data libraries, such asPandasandMatplotlib.HyFive vs. Vanilla PandasPandasDataFramehas its own quirks. It ranges from not having afiltermethod to having a different definiton ofjointo that of SQL. This is evident from the bewildering comparison betweenPandas and SQL. HyFive aims to provide a Lispy interface that is as close as possible to that ofSpark'sSQL and DataFrame.From a functional programming perspective, Pandas interfaces are oddly difficult to compose unlike Spark SQL's method-chaining convention. Due to this difficulty, Pandas often perversely incentivises short names for dataframes in favour of creating intermediate variables, which litters the namespace.HyFive utilises Hy's threading macros to mimic Spark DataFrame's method chaining convention, whilst staying with the familiar Pandas dataframe. Consider the following HyFive snippet:(setvDATAFRAME(->NAME-REGISTRY(hf.with-column"variant"(let[mod-res-id(hf.mod"resident_id"3)](hf.cond-col[(hf.eq?mod-res-id1)(hf.lit"a")][(hf.eq?mod-res-id2)(hf.lit"b")][:else(hf.lit"c")])))(hf.filter(hf.is-in"variant"["a""b"]))(hf.joinAGE-REGISTRY:on"resident_id")(hf.group-by"variant")(hf.agg{"min_age"(hf.min"age")"mean_age"(hf.mean"age")"std_age"(hf.std"age")"max_age"(hf.max"age")})(hf.order-by"min_age":descTrue)))Here, we carry out simple operations of adding a column, filtering rows, joining tables, aggregating groups and sorting rows. Apart from the Lispycond, these operations would have a one-to-one translation to Spark dataframe or SQL.In contrast, one would have to work a bit harder in pure Pandas:mod_res_id=NAME_REGISTRY.resident_id%3variant=np.where(mod_res_id==1,'a',np.where(mod_res_id==2,'b','c'))select_ix=np.isin(variant,['a','b'])dataframe=(NAME_REGISTRY.assign(variant=variant)[select_ix].merge(AGE_REGISTRY,on='resident_id').groupby('variant').apply(lambdadf:pd.Series({'min_age':df.age.min(),'mean_age':df.age.mean(),'std_age':df.age.std(),'max_age':df.age.max()})).reset_index().sort_values(by='min_age',ascending=False).reset_index(drop=True))The Pandas version is less readable and we lose the one-to-one translation to Spark dataframe or SQL.Trying HyFiveClone the repository, and on the root directory of the enter the following command on terminal:./runbuild-dockerRun the unit tests with the following command:./rununit-tests.Invoke the Hy REPL by running:./runreplAnd finally, import HyFive using:(import[hyfive:ashf])
Package: dev-achievements
dev-achievementsEarn Achievements while learning how to codeGame-ify your experience while learning to code and get achievements for different concepts as you use them. Start off at a simpleprintstatement and work your way up tofunctionsandclasses(and more to come).ExampleJustimportthe package at the top of your script (example):# my_script.pyimportdev_achievementsdefcumulative_sum(x):# calculates sum of numbers from 0 to xtotal=0foriinrange(x):total+=ireturntotalresult=cumulative_sum(4)print('value: ',result)And run it in terminal as you normally would:$python3my_script.py

┌──────────────────────────────────┐
│AchievementUnlocked:Loops!│
│AchievementUnlocked:Functions!│
└──────────────────────────────────┘

value:6UsageInstall the package withpip install dev-achievementsUseimport dev_achievementsat the top of your scriptRun yourpythonscript as normalSome things to noteCurrently thisonlyworks on single file scripts - if you import your own module (e.g. for utility functions) that module willnotbe parsed (planning on fixing this though)Some achievements havedependencies, and will only be unlocked once previous ones have been unlockedUnlocked achievements will remain unlocked, so those "Achievement Unlocked" messages will should only show once per achievementFuture plans and contributingThe bare bones achievements are currently implemented (using"hello world",forloops,lists,functions, etc.) - more achievements are in development (see issue#1)More details on how to contribute (along with code docs to help with the development process) are coming soon
Package: devana
DevanaDevana is a python tool that make it easy to parsing, format, transform and generate C++ (or C) code.
This tool uses libclang to parse the code. Fundamental problems, bugs and missing features of libclang are fixed in
Devann's internal code.Please note that Devana focuses on the header-level code e.g. class and functions definitions, templates resolving,
typedefs and includes. Control statements, arithmetics operations etc. (pure body of functions) are supported as access
to raw string field "body". It is planned to introduce more control over this type of code in future versions.Important:Devana is still under development. At the moment, parsing and basic code generation is available
(almost full coverage of development plans). Please checkroadmap.InstallationDevana is published onPyPIand can be installed from there:pip install -U devanaIf you wish to install Devana for development purposes, refer to the contributors guide.How to startYou can find the complete guide inthissection of the documentation.Demo applications are located in project repository inside demo folder.DocumentationDocumentation is available fromGitHub Pages.ContributingPlease checkcontributing guidefor take more details about contributing this project.For now, the most wanted help is bugreports, bugfix, writing test and parser features completion. You can write e-mail
to me directly with question about help.TestingContinuous testing isGitHub Actions.
For information on running tests locally, refer to the contributors guide.RoadmapA detailed list of missing functionalities and planned features can be found in thedocumentation.AcknowledgmentsFor providing a very good development environment within Free License Programs for Open Source.
Package: devanagari
devanagariNLP library for nepali textual datasetProject Organization├── LICENSE
├── Makefile           <- Makefile with commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default Sphinx project; see sphinx-doc.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
├── src                <- Source code for use in this project.
│   ├── __init__.py    <- Makes src a Python module
│   │
│   ├── data           <- Scripts to download or generate data
│   │   └── make_dataset.py
│   │
│   ├── features       <- Scripts to turn raw data into features for modeling
│   │   └── build_features.py
│   │
│   ├── models         <- Scripts to train models and then use trained models to make
│   │   │                 predictions
│   │   ├── predict_model.py
│   │   └── train_model.py
│   │
│   └── visualization  <- Scripts to create exploratory and results oriented visualizations
│       └── visualize.py
│
└── tox.ini            <- tox file with settings for running tox; see tox.readthedocs.ioProject based on thecookiecutter data science project template. #cookiecutterdatascience
Package: devanagari-nlp
devanagari_nlpNLP library for nepali textual datasetProject Organization├── LICENSE
├── Makefile           <- Makefile with commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default Sphinx project; see sphinx-doc.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
├── src                <- Source code for use in this project.
│   ├── __init__.py    <- Makes src a Python module
│   │
│   ├── data           <- Scripts to download or generate data
│   │   └── make_dataset.py
│   │
│   ├── features       <- Scripts to turn raw data into features for modeling
│   │   └── build_features.py
│   │
│   ├── models         <- Scripts to train models and then use trained models to make
│   │   │                 predictions
│   │   ├── predict_model.py
│   │   └── train_model.py
│   │
│   └── visualization  <- Scripts to create exploratory and results oriented visualizations
│       └── visualize.py
│
└── tox.ini            <- tox file with settings for running tox; see tox.readthedocs.ioProject based on thecookiecutter data science project template. #cookiecutterdatascience
Package: devanalyst
devtoolsThedevtoolspackage provides support for data-driven analysis of a software development's team efficiency.
At present it provides support for:Simulation of a release cycle:User story burndownIn the future it is planned to provide support as well for:Simulation of a release cycle:Bug inflowSource commitsEfficiency metricsCommon model for the data inputs associated to a release cycleMathematical definition of efficiency metricsData analysisAbility to validate or refute efficiency hypothesisHotspotting to pin down inefficiency drivers in the code or the team
Package: devantech-eth
devantech_ethA python3 library for controlling the Devantech ETHxxx range of modules.This library works with:ETH002-BETH008-BETH484-BETH8020-BInstallYou can install the module with pip.pip -m install devantech-ethGetting startedThis example shows creating an instance of the ETH002 class, connecting to the module and toggling relay one.# import the eth002 module from devantech-ethfromdevantech_ethimporteth002# Create an instance of the ETH002 class and try connecting to the modulemodule=eth002.ETH002(ip="192.168.0.100",port=17494,password="password")module.connect()# Toggle digital output 1module.toggleDO1()# Close the connection to the modulemodule.close()This example shows creating an instance of the ETH484 class, connecting to the module and reading the value of an analogue input.# import the eth484 modulefromdevantech_ethimporteth484# create an instance of the ETH484 class and connect to the modulemodule=eth484.ETH484(ip="192.168.0.100",port=17494,password="password")module.connect()# Get and print the value of analogue input 1value=module.getAI1Value()print(value)# Close the connection to the module.module.close()SourceThe source for this library is available ongithubDocumentation can be readhere
Package: devblaze
DevBlazeDevBlaze is a Python library that provides a streamlined process for creating new Django projects. It is used as a core component in theStreamline Cookiecutterproject, which focuses on fast development and deployment of Django applications.DevBlaze leverages the power ofTextualto provide a custom CLI, enhancing the user experience and simplifying the creation of Django projects.Please note: DevBlaze is currently in alpha and may be subject to changes.Getting StartedTo get started with DevBlaze, follow these steps:Install DevBlaze:pip install devblazeGenerate a new project:devblaze generateFollow the prompts to create your project.
You will be prompted to enter some values. After that, the project will be created in the current directory.DevBlaze also supports make shortcuts for an even simpler user experience. Check the Streamline Cookiecutter project for more details.Why DevBlaze?Traditional cookiecutter templates are great, but DevBlaze takes it a step further. By leveraging the Textual library, DevBlaze provides a more interactive and user-friendly interface, making the process of creating new Django projects even easier and more enjoyable.ContributingContributions are welcome! Please seeCONTRIBUTING.mdfor more details.LicenseDevBlaze is licensed under theMIT License.
Package: devcache
ï»¿# devcache
A configurable decorator allows methods to return persistently stored data from a cache instead of a normal call.The use case is to speed up development by caching data from long-running methodsInstallationpip install devcacheSituationYou're working on a project that syncs data from a Database to a CRM.defget_crm_data():# Takes multiple minutes...defget_db_data():# Takes multiple minutes...defcompare_and_report():crm_data=get_crm_data()db_data=get_db_data()...diff=...result=save_data(diff)...send_report(report)defsave_data(data):# Takes more than a minute...As you are trying to improvecompare_and_reportit takes 5 minutes for everytime you run.A possible solution would be to usedevcache, like so:Decorate appropriate methods@devcache(group='crm')defget_crm_data():# Takes multiple minutes...@devcache(group='db')defget_db_data():# Takes multiple minutes...@devcache(group='save')defsave_data(data):# Takes more than a minute...Create a config at ~/.devcache/devcache.yamlprops:1:group:crmuse_cache:true2:group:dbuse_cache:true3:group:saveuse_cache:trueNow the methods will pull data from the cache asuse_cacheistrue.  If a change was required to any saved data set theuse_cachetofalseand data will be generated and stored fresh in the cache.Now using the cache each testing iteration takes seconds instead of minutes.Other useful configurationrefresh:true# refresh true will ignore use_cache and refresh all cached dataenabled:false# will disable everything and will not save new values to cacheprops:1:group:crmuse_cache:false2:group:dbuse_cache:true3:group:saveuse_cache:true-1:# first props match is used.# ordering is by the key (ie -1, 1 ,2 ,3)# 'group' is optionalpattern:'.*sfdc.*'# matches fully qualified name of the method.# this pattern would match everything in a module called sfdcuse_cache:trueenabled:true# Can turn off props with enabled.  Will allow for other props to potentially matchOther devcache args# devcache defaults to not take into account the args@devcache(group='crm',key_args=('a',))defmy_method(a,b,c):# Will cache result using only arg 'a' value as part of the key...@devcache(group='crm',ignore_key_args=('c',))defanother_method(a,b,c):# Will cache result using arg 'a', 'b' value as part of the key ignoring 'c'...@devcache(config_file='../alternate.yaml')defmethod3(a,b,c):# specify another configuration...Important WarningThis project is only useful to speed up development and is a security risk.Best practice would be to not includedevcachein project requirements for production and only installing it locally.Creating project specific decorator will allow for functionality to work in the desired env and not break the other.For example:defcacher(config_file=None,group=None,key_args=None,ignore_key_args=None):defnoop_decorator(func):returnfunc# pass throughtry:fromdevcacheimportdevcachereturndevcache(config_file=config_file,group=group,key_args=key_args,ignore_key_args=ignore_key_args)except:returnnoop_decoratorUsing@cacherdecorator would have use a pass through decorator for prod but usedevcachewhere it's installed.
Package: devchat-ask
DevChatAsk everything about your dev data beyond the code.DependenciesPlease install the following dependencies and ensure their installation path are added to yourPATHenvironment variable (or export environment variables:CINDEX_CMD_PATHandCSEARCH_CMD_PATH).NameDescriptionInstallationcindexCindex prepares the trigram index for use by csearch. The index is the file named by $CSEARCHINDEX, or else $HOME/.csearchindex.Usage:cindex [-list] [-reset] [path...]go get github.com/google/codesearch/cmd/cindex@latestcsearchCsearch behaves like grep over all indexed files, searching for regexp, an RE2 (nearly PCRE) regular expression.Usage:csearch [-c] [-f fileregexp] [-h] [-i] [-l] [-n] regexpgo get github.com/google/codesearch/cmd/csearch@latest
Package: dev-cli
A CLI interface for dev.toPlease note before using that you should put yourAPI
keyin theDEV_API_KEYenvironment variable. If you prefer, when starting the
program will also look for a.envfile in the working directory.You can get this tool simply by doing a:pip install dev-cliPublishingYou can publish a Markdown file directly to dev.to using DEV-CLI. Your
Markdown file must be identical to what you would input directly in the
website’s interface.Something else that you should take in account is the key. Indeed, when
an article is created the API ID isn’t retrofitted to the Markdown file
since this would get a little bit messy. Instead, you have several
options to map your local files to your remote articles.Namely you can use thecover_picture, thecanonical_urlor thetitlefrom the front matter. Please note that whatever you chose it
must be set in the front matter, otherwise the program will fail. The
default key iscanonical_url, because it won’t appear in your source
file unless you know what you’re doing.Please note that you don’t have to use the same key every time. Suppose
that you use thetitlebut want to change it, you can do one sync
withcover_pictureinstead oftitleas long as you don’t change
both at the same time.To publish using thecanonical_url:python -m dev_cli publish ~/dev/dev-blog/test.mdTo publish using another key:python -m dev_cli publish -k title ~/dev/dev-blog/test.mdIn case of conflict the first found article will be updated.
Package: devconfig
rfc2119 for keywordsPURPOSEto provide unified way to configurepython2andpython3applicationto be handy for developers, devops, QA and users with technical backgroundREADINGSyaml tutorialhttp://yaml.org/spec/1.1/YAML IS NOT A JSON AND NOT A DATA SERIALIZATION FORMAT. ITS A OBJECT SERIALIZATION FORMATREQUIREMENTSMUSTsupport yaml out of the boxMUSTconfigure program (standalone module or python package) by recursive merge developer defined configuration (defaults) and runtime provided configuration.each configuration layer (e.g. defaults, runtime config, etc.)MUSTbe a nested mappingnumber of merged layers is unlimited andMAYbe redefined by developerlayer merge orderMAYbe redefined by developerMUSTcontain set of yamlconstructors!url!date!datetime!timedelta!strjoin!envvar!regexp!filecontentSHOULDcontain set of dangerous yaml constructors!file!socket!yamlfile- includes yaml by file path or urlMAYprocess constructors with recursion detection (see REQUIREMENT NOTES)MAYcontain cli arg mapping constructorsSHOULDprovide a way to extend set of constructors before configuration loadedMUSTprovide a way to configure logging usinglogging.dictConfigand values from merged configurationruntime configuration pathMAYbe redefined with envvar (like$ CONFIG=./some-config.yml program.py)runtime configuration pathMAYbe redefined with cli arg (like$ program.py --config=./some-config.yml)SHOULDenable sharing ofanchorsbetween layersSHOULDNOT allow to redefine anchors that alredy defined in previous layersMUSTsupport filesystem path as configuration pathMUSTsupportfile://,http(s)://urls as configuration pathMAYsupportftp://urls as configuration pathMAYsupportgit://urls as configuration pathREQUIREMENT NOTES!class,!object, and!yamlfileare considered dangerous since class or object creation may require existing configuration that is not exists during constructor call.!yamlfilecan refer!classor!objectinside and/or cause infinte yaml load recursion or module load recursion.!fileand!socketare considered dangerous since they are not serializableIMPLEMENTATIONprovides<module>.<config>submodule that contains resulting configuration as mapping???