Saravanan666/pypi-org huggingface dataset:
Package: adr
ADR-pyShout to excellentadr-toolsproject on whichADR-pyis based onThis Python script is designed to help software development teams document their architecture decisions using Architecture Decision Records (ADRs).
ADRs are a lightweight and effective way to capture important decisions made during the design and development of a software system, and to keep track of their rationale and implications over time.The script creates ADR files in a predefined format, following the principles ofMichael Nygard's ADR template.
Each ADR file is a Markdown document with a unique name that includes a sequential number and a title, which is automatically generated based on the information provided by the user.PrerequisitesPython 3.11 installed on your system.Basic knowledge of command-line interface (CLI) usage.Installationpip install adrHow to UseUsage:$adr[OPTIONS]COMMAND[ARGS]...Options:--install-completion: Install completion for the current shell.--show-completion: Show completion for the current shell, to copy it or customize the installation.--help: Show this message and exit.Commands:init: Initialize ADR directory with first ADR in given PATHnew: Create new ADR with given NAMEinitInitialize ADR directory with first ADR in given PATHUsage:$adrinit[OPTIONS][PATH]Arguments:[PATH]: Path in where ADRs should reside. If not provided Path will be extracted from pyproject.tomlOptions:--help: Show this message and exit.newCreate new ADR with given NAMEUsage:$adrnew[OPTIONS]NAMEArguments:NAME: Name of new ADR. Longer names (with spaces) should be put in quotation marks.  [required]Options:adr --help: Show this message and exit.ADR TemplateThe generated ADR files follow the template proposed by Michael Nygard in his book "Documenting Architecture Decisions." The template consists of the following sections:Title: The title of the ADR.Status: The current status of the decision (e.g., proposed, accepted, rejected).Context: The context and background information that led to the decision.Decision: The decision made and its rationale.Consequences: The potential consequences and trade-offs of the decision.Benefits of ADRsUsing ADRs has several benefits for software development teams, including:Documentation: ADRs provide a written record of important architectural decisions, making it easier for team members to understand the reasons behind past decisions.Communication: ADRs serve as a communication tool for discussing and documenting design decisions, facilitating collaboration among team members.Decision-making: ADRs encourage thoughtful decision-making by requiring the team to consider the context, rationale, and potential consequences of each decision.Transparency: ADRs promote transparency by making architectural decisions visible and accessible to the entire team, fostering a culture of shared understanding and accountability.Knowledge sharing: ADRs help capture the collective knowledge and experience of the team, enabling future team members to learn from past decisions and avoid repeating mistakes.
Package: adr.ca
ADRAircraft Design Resources aims to help engineers on conceptual design analysis, giving them the tools necessary to easily simulate different aircraft designs.InstallationRegular usagegit clone https://github.com/CeuAzul/ADR.git
cd ADR
pip install setuptools
pip install ./Developmentgit clone https://github.com/CeuAzul/ADR.git
cd ADR
pip install setuptools
pip install -e ./UsageTo run an analysis modify the inputs onparameters.pyas needed and runmain.py.ContributorsThis project exists thanks to all the people who contribute.
Package: adrenaline
adrenalineSimple Python module to prevent your computer from going to sleep. Supports
Windows and macOS at the moment; Linux support is coming soon (hopefully).UsageThe module provides a context manager namedprevent_sleep(). The computer
will not go to sleep while the execution is in this context:fromadrenalineimportprevent_sleepwithprevent_sleep():# do something important here...Optionally, you can also prevent the screen from turning off:withprevent_sleep(display=True):# do something important here...Command line interfaceYou can also use this module from the command line as follows:$python-madrenalineThe command line interface will prevent sleep mode as long as it is running.AcknowledgmentsThanks toMichael Lynnfor figuring out
how to do this on macOS.Thanks toNiko Pasanenfor the Windows
version.
Package: adrest
Adrest is Another Django REST. Django application for simple make HTTP REST API.Documentation inconstruction.RequirementsPython 2.7Django (1.5, 1.6, 1.7)InstallationADRestshould be installed using pip:pip install adrestQuick startfrom adrest import Api, ResourceView

api = Api('v1')

@api.register
class BookResource(ResourceView):
    class Meta:
        allowed_methods = 'get', 'post'
        model = 'app.book'

urlpatterns = api.urlsSetupAdrest settings (default values):# Enable logs
ADREST_ACCESS_LOG = False

# Auto create adrest access key for User
ADREST_AUTO_CREATE_ACCESSKEY = False

# Max resources per page in list views
ADREST_LIMIT_PER_PAGE = 50

# Display django standart technical 500 page
ADREST_DEBUG = False

# Limit request number per second from same identifier, null is not limited
ADREST_THROTTLE_AT = 120
ADREST_THROTTLE_TIMEFRAME = 60

# We do not restrict access for OPTIONS request
ADREST_AUTHENTICATE_OPTIONS_REQUEST = FalseNoteAdd ‘adrest’ to INSTALLED_APPSUse adrestSee test/examples in ADREST sources.Bug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/klen/adrest/issuesContributingDevelopment of adrest happens at github:https://github.com/klen/adrestContributorsklen(Kirill Klenov)LicenseLicensed under aGNU lesser general public license.
Package: adrf
Async Django REST frameworkAsync support for Django REST frameworkRequirementsPython 3.8+Django 4.1+Wehighly recommendand only officially support the latest patch release of
each Python and Django series.InstallationInstall usingpip...pip install adrfAdd'adrf'to yourINSTALLED_APPSsetting.INSTALLED_APPS=[...'adrf',]ExamplesAsync ViewsWhen using Django 4.1 and above, this package allows you to work with async class and function based views.For class based views, all handler methods must be async, otherwise Django will raise an exception. For function based views, the function itself must be async.For example:fromadrf.viewsimportAPIViewclassAsyncAuthentication(BaseAuthentication):asyncdefauthenticate(self,request)->tuple[User,None]:returnuser,NoneclassAsyncPermission:defhas_permission(self,request,view)->bool:ifrandom.random()<0.7:returnFalsereturnTrueclassAsyncThrottle(BaseThrottle):defallow_request(self,request,view)->bool:ifrandom.random()<0.7:returnFalsereturnTruedefwait(self):return3classAsyncView(APIView):authentication_classes=[AsyncAuthentication]permission_classes=[AsyncPermission]throttle_classes=[AsyncThrottle]asyncdefget(self,request):returnResponse({"message":"This is an async class based view."})fromadrf.decoratorsimportapi_view@api_view(['GET'])asyncdefasync_view(request):returnResponse({"message":"This is an async function based view."})Async ViewSetsFor viewsets, all handler methods must be async too.views.pyfromdjango.contrib.authimportget_user_modelfromrest_framework.responseimportResponsefromadrf.viewsetsimportViewSetUser=get_user_model()classAsyncViewSet(ViewSet):asyncdeflist(self,request):returnResponse({"message":"This is the async `list` method of the viewset."})asyncdefretrieve(self,request,pk):user=awaitUser.objects.filter(pk=pk).afirst()returnResponse({"user_pk":useranduser.pk})urls.pyfromdjango.urlsimportpath,includefromrest_frameworkimportroutersfrom.importviewsrouter=routers.DefaultRouter()router.register(r"async_viewset",views.AsyncViewSet,basename="async")urlpatterns=[path("",include(router.urls)),]Async Serializersserializers.pyfromadrf.serializersimportSerializerfromrest_frameworkimportserializersclassAsyncSerializer(Serializer):username=serializers.CharField()password=serializers.CharField()age=serializers.IntegerField()views.pyfrom.importserializersfromadrf.viewsimportAPIViewclassAsyncView(APIView):asyncdefget(self,request):data={"username":"test","password":"test","age":10,}serializer=serializers.AsyncSerializer(data=data)serializer.is_valid()returnawaitserializer.adata
Package: adrianna
A powerfull lib, for development in machine learningInstall:$pipinstalladrianna-UExamples:BasesNeuro V1 (binary)fromadrianna.neuro.base_v1importNeuralNetworkimportnumpyasnp# Exemplo de usoif__name__=="__main__":# Dados de entrada e saídaX=np.array([[3,1,2],[1,24,5],[2,42,5],[2,23,3]])y=np.array([[1],[0],[1],[0]])# Criação e treinamento da rede neuralinput_size=X.shape[1]# Número de colunas das listashidden_size=4# Número de neurônios na camada ocultaoutput_size=y.shape[1]# Número de saídasneural_net=NeuralNetwork(input_size,hidden_size,output_size,learning_rate=0.1)neural_net.train(X,y,epochs=10000)# Fazendo previsõespredictions=neural_net.predict(X)predictions=np.round(predictions).astype(int)print("Predictions:")print(predictions)Results:...
Epoch8000,Loss:0.2617957
Epoch8100,Loss:0.1830651
Epoch8200,Loss:0.1800935
Epoch8300,Loss:0.2585192
Epoch8400,Loss:0.3310709
Epoch8500,Loss:0.3215849
Epoch8600,Loss:0.1803035
Epoch8700,Loss:0.1802555
Epoch8800,Loss:0.1807692
Epoch8900,Loss:0.3312975
Epoch9000,Loss:0.1800601
Epoch9100,Loss:0.2642676
Epoch9200,Loss:0.1930688
Epoch9300,Loss:0.3279387
Epoch9400,Loss:0.1871483
Epoch9500,Loss:0.1809427
Epoch9600,Loss:0.2635577
Epoch9700,Loss:0.1855325
Epoch9800,Loss:0.1796770
Epoch9900,Loss:0.1800897

Predictions:[[1][0][1][1]]
Package: adroit
adroit- Ansible Docker Role TestingHeavily opinionated tool for testing Ansible roles using Docker containers.Assumptions and limitationsThese are the current assumptions about your Ansible codebase which might prevent you from using Adroit. They are subject to change or improve.You only deploy (or only want to test) on modern systems with systemd as their init system.You have abaserole which other roles can build upon. (If you don't need this, you can just have an emptyroles/basedirectory).With the exception of depending on the base role, your Ansible roles are atomic, indepentent, and can be applied individually.include_roleand dependencies defined inmetashould still work, though.Feel free to open a Github issue about any limitations that prevent you from using Adroit.How it worksAdroit builds acore imagebased on your distro of choice.A container based on the core image is created. Thebaserole will be applied to the container, and it is saved as thebase image.For each role you want to test, a container based on the base image is started, and the role under test will be applied.Adroit will check if the role playbook fails, and will also run the playbook a second time to test for idempotency - if there are any changes on the second run, we consider it a failure.PrecautionsTo properly test Ansible using Docker containers, systemd needs to be running inside the containers. This requires the containers to run in privileged mode. There is a security risk involved here, check your base images and playbooks accordingly.UsageIn a virtualenv or whatever you prefer:pip install adroitIn the root directory of your Ansible tree structure, which should at least contain arolesdirectory, run this command:adroit-ddebian:stretchmyroleWheredebian:stretchis the image you want to base your tests on. Currently supported are Debian, Ubuntu and CentOS.Customizing your roles for testingCertain tasks simply cannot be ran inside a Docker container - for example, mounting/procwithhidepid=2. You should add awhenclause to these tasks. Example:-when:ansible_virtualization_type != 'docker'import_tasks:configure_network.ymlIf you need certain variables to be set which aren't indefaultsorvarsbut should be set during testing, you can create a file likeroles/myrole/testing/test_vars.ymland it will be applied when testing that particular role.LicenseThe contents of this repository is released under theMIT license. See the LICENSE file included for details.
Package: adrt
Approximate Discrete Radon TransformFast approximate discrete Radon transform forNumPyarrays.Documentation:https://adrt.readthedocs.io/en/latest/Source Code:https://github.com/karlotness/adrtBug Reports:https://github.com/karlotness/adrt/issuesThis library provides an implementation of an approximate discrete
Radon transform (ADRT) and related routines as a Python module
operating on NumPy arrays. Implemented routines include: the forward
ADRT, a back-projection operation, and several inverse transforms. The
packagedocumentationcontains usage examples, and sample
applications.InstallationInstall fromPyPIusing pip:$python-mpipinstalladrtFor further details on installation or building from source, consult
thedocumentation.ReferencesThis implementation is based on descriptions in several publications:Martin L. Brady,A Fast Discrete Approximation Algorithm for the Radon Transform Related Databases, SIAM Journal on Computing, 27.William H. Press,Discrete Radon transform has an exact, fast inverse and generalizes to operations other than sums along lines, Proceedings of the National Academy of Sciences, 103.Donsub Rim,Exact and fast inversion of the approximate discrete Radon transform from partial data, Applied Mathematics Letters, 102.LicenseThis software is distributed under the 3-clause BSD license. See
LICENSE.txt for the license text.We also make available several pre-built binary copies of this
software. The binary build for Windows includes additional license
terms for runtime code included as part of the software. Review the
LICENSE.txt file in the binary build package for more information.
Package: adr-tools-python
READMEThis is a project to get a python equivalent of the adr-tools by npryce ongithub. The tool can make and list and change Architecture Decision Records. For more information on Architecture Decision Records see the page ofJoel Parker Henderson on ADRs.Installationpip install adr-tools-pythonorpython3 -m pip install adr-tools-python --userBy adding a--upgradeflag, the tool can be updated if a new version is availableUsageadr-initWithadr-init, the directory structure can be initialized. Default, a subdircectorydoc/adris generated, but if a different directory is wished for, this can be input:adr-init fooIn this case, adrs will be stored in a local folderfoo/. In the main directory, a file called.adr-diris generated to indicate toadr-toolsthat a different location than the defaultdoc/adr/is used. This behaviour was copied from, and should be compatible with the originaladr-tools.adr-initalways creates a new adr to say that adrs will be used.adr-newA subject should be given for a new adr:> adr-new create equal animals
> adr-list
doc/adr/0001-record-architecture-decisions.md
doc/adr/0002-create-equal-animals.md
>ADRs can be superceded from the command line using the-soption, and be linked by using the-loption.From the documentation ofadr-tools:Multiple -s and -l options can be given, so that the new ADR can supercedeor link to multiple existing ADRs.E.g. to create a new ADR with the title "Use MySQL Database":adr new Use MySQL DatabaseE.g. to create a new ADR that supercedes ADR 12:adr new -s 12 Use PostgreSQL DatabaseE.g. to create a new ADR that supercedes ADRs 3 and 4, and amends ADR 5:adr new -s 3 -s 4 -l "5:Amends:Amended by" Use Riak CRDTs to cope with scaleThe same funcitonality is also available in this python versionadr-listSee above, lists the adrs.Serving the adrsIf you want the ADRs to be served on a webpage, please look for the python package [adr-viewer](https://pypi.org/project/adr-viewer/Source, contributionThe source code is available onbitbucket. If you're interested in collaborating let me know, and/or send a merge request.ThanksThanks to Michael Nygard for the originalidea of ADRs, WesleyKS for his work onadre(which was inspiring, but not the road I followed), and of course to Npryce for making and documenting thebash toolchainI tried to replicate in Python.
Package: adr-viewer
adr-viewerShow off your Architecture Decision Records with an easy-to-navigate web page, either as a local web-server or generated static content.ExamplesExample above using Nat Pryce'sadr-toolsprojectThis project exposes its own Architecture Decision RecordshereInstallationFrom PyPI$pipinstalladr-viewerFrom local buildadr-viewer requires Python 3.7 or higher (with Pip)$gitclonehttps://github.com/mrwilson/adr-viewer
$pipinstall-rrequirements.txt
$pythonsetup.pyinstallUsageUsage:adr-viewer[OPTIONS]Options:--adr-pathTEXTDirectorycontainingADRfiles.[default:doc/adr/]--outputTEXTFiletowriteoutputto.[default:index.html]--serveServecontentathttp://localhost:8000/--portINTCustomserverport[default:8000]--helpShowthismessageandexit.The default for--adr-pathisdoc/adr/because this is the default path generated byadr-tools.Supported Record Types
Package: ads
A Python Module to Interact with NASA’s ADS that Doesn’t Suck™If you’re in astro research, then you pretty muchneedNASA’s ADS.
It’s tried, true, and people go crazy on the rare occasions when it goes down.Docs:https://ads.readthedocs.io/Repo:https://github.com/andycasey/adsPyPI:https://pypi.python.org/pypi/adsQuickstart>>> import ads
>>> ads.config.token = 'secret token'
>>> papers = ads.SearchQuery(q="supernova", sort="citation_count")
>>> for paper in papers:
>>>    print(paper.title)
[u'Maps of Dust Infrared Emission for Use in Estimation of Reddening and Cosmic Microwave Background Radiation Foregrounds']
[u'Measurements of Omega and Lambda from 42 High-Redshift Supernovae']
[u'Observational Evidence from Supernovae for an Accelerating Universe and a Cosmological Constant']
[u'First-Year Wilkinson Microwave Anisotropy Probe (WMAP) Observations: Determination of Cosmological Parameters']
[u'Abundances of the elements: Meteoritic and solar']Running Tests> cd /path/to/ads
> python -m unittest discover
Package: ads1015
ADS1015 4 channel differential/single-ended ADCInstallingStable library from PyPi:Just runpython3 -m pip install ads1015Latest/development library from GitHub:git clone https://github.com/pimoroni/ads1015-pythoncd ads1015-python./install.sh --unstable1.0.0Enhancement: Repackage to pyproject.toml/hatchlingIsort and black code formatting0.0.8Add thread-safe wrapper around ADC readsMinor spelling fixes0.0.7Fix setting data rateAdd support for ADS1115Add new detect_chip_type function0.0.6Added support for all addresses ads1015 supportsGenericized implementation away from pimoroni breakoutTypo fixes in docstringFix get_multiplexer so that it returns a value0.0.5Fix to support alternate i2c addressTypo fixes in DocString and comment0.0.4Port to i2cdevice>=0.0.6 set/get API0.0.3Fixed timeout in wait_for_conversionAliased timeout exception to ads1015.ADS1015TimeoutError0.0.2Fixed Python 2.7 bug with missing TimeoutError0.0.1Initial Release
Package: ads2gephi
ads2gephiis a command line tool for querying and modeling citation networks from the Astrophysical Data System (ADS) in a format compatible with Gephi, a popular network visualization tool. ads2gephi has been developed at the history of science department of TU Berlin as part ofa research project on the history of extragalactic astronomyfinanced by the German Research Foundation DFG (PI Karin Pelte).You can installads2gephifrom PyPI:pip install ads2gephiUsageWhen using the tool for the first time to model a network, you will be prompted to enter your ADS API key. Your key will then be stored in a configuration file under ~/.ads2gephi.In order to sample an initial citation network, you need to provide ads2gephi with a plain text file with bibcodes (ADS unique identifiers), one per line, as input. The queried network will be output in a SQLite database stored in the current directory:ads2gephi -c bibcodes_example.txt -d my_fancy_netzwerk.dbAfterwards you can extend the queried network by providing the existing database file and using the additional sampling options. For example, you can extend the network by querying all the items cited in every publication previously queried:ads2gephi -s ref -d my_fancy_netzwerk.dbFinally you might want to also generate the edges of the network. There are several options for generating edges. For example you can use a semantic similarity measure like bibliographic coupling or co-citation:ads2gephi -e bibcp -d my_fancy_netzwerk.dbYou can also do everything at once:ads2gephi -c bibcodes_example.txt -s ref -e bibcp -d my_fancy_netzwerk.dbAll other querying and modelling options are described in the help page:ads2gephi --helpOnce you've finished querying and modeling, the database file can be directly imported in Gephi for network visualization and analysis.Special thanks toEdwin Henneken
Package: ads2inspire
ads2inspireReplace ADS citations with the appropriate INSPIRE ones in latex and bibtexWhy? Because ADS citation keys are not stable: they start out as something like2019arXiv191207609s,
and after being accepted to a journal turn into something like2020PhRvD.101f4007S. This means you
have to rewrite your latex, or you might even end up citing both entries!InstallationFrom PyPIIn your Python environment runpython -m pip install ads2inspireFrom conda-forgeIn your conda environment runconda install -c conda-forge ads2inspireFrom this repositoryIn your Python environment from the top level of this repository runpython -m pip install .From GitHubIn your Python environment runpython -m pip install "git+https://github.com/duetosymmetry/ads2inspire.git#egg=ads2inspire"UsageFirst latex/bibtex/latex your file, then runads2inspire[--backup][--filter-type[ads|all]][--fill-missing]auxfile.aux[texfile1.tex[texfile2.tex[...]]]If your main tex file is namedwonderful.tex, then your auxfile will be namedwonderful.aux.ads2inspirewill read the aux file, query INSPIRE, then rewrite all the texfiles named on the
command line, and append to the first bibtex file named in auxfile.  The option--backupwill
make the program write backups of the tex and bib files before rewriting them.  The option--filter-typecontrols which keys to search for on INSPIRE: the default"ads"will only
search for keys that look like ADS keys, while"all"will try all keys (aside from those that
look like INSPIRE keys).
The--fill-missingflag will query for INSPIRE-like keys that were
referenced in the LaTeX source, but missing from the .bib file, and
fill them into the .bib file if found.ContributingNote that I have done very little testing! Want to pitch in and help make this code better?
Please fork and send me PRs!TODO:More testingMore filter typesmore?CitationThe preferred BibTeX entry for citation ofads2inspireis@software{ads2inspire,
  author = "{Stein, Leo C. and Feickert, Matthew}",
  title = "{ads2inspire: v0.3.1}",
  version = {v0.3.1},
  doi = {10.5281/zenodo.3903987},
  url = {https://github.com/duetosymmetry/ads2inspire},
}
Package: ads-async
Asyncio (or sans-i/o) TwinCAT AMS/ADS testing server in pure Python.… and maybe a prototype client, too.RequirementsPython 3.9+(Optional) pytmc (for loading .tmc files in the server)Server FunctionalityReference asyncio implementation.Loads .tmc files for symbol information (basic types only).Supports read, write, read/write of symbols (by handle or name).Supports ‘sum up’ bulk reads (by way of read_write).Pretends to create/delete notifications (not yet working)Client FunctionalityPreliminary symbol, handle, and notification supportLOGGER port message decodingShortcuts for common information (project/application/task names, task count)Ability to easily prune unknown notification handlesAutomatic reconnectionLog system configurationInstallation$ git clone git@github.com:pcdshub/ads-async
$ cd ads-async
$ pip install .Running the Tests$ pip install pytest
$ pytest -vv ads_async/tests
Package: adsb
ADS-B tools for PythonThe adsb package currently provides tools for working with ADSB messages
produced by software that provides BaseStation-like output, such asdump1090.This project is very early in development.Quickstartadsb is available on PyPI and can be installed withpip.$pipinstalladsbAfter installing adsb you can use it like any other Python module.Here is a simple example:importadsb# Fill this section in with the common use-case.TheAPI Referenceprovides API-level documentation.Change LogVersion History0.0.1Project created.