Saravanan666/pypi-org huggingface dataset:
Package: ask-the-wizard
Ask The Wizard - Wizardry at its bestAre you still thinking while coding or are you already Asking The Wizard? 🧙Overview 🌟Welcome to Ask The Wizard, the revolutionary Python module package system that not only embraces side effects but celebrates
them! Here, we believe that every side effect is a hidden feature waiting to be discovered. 🎉Features 🚀Integrated Package Management:Automatically install pip packages used in your code. No morepip install! 📦Enthusiastic Side Effects: Every operation inAsk The Wizardis accompanied by a delightful surprise. Side
effects are not bugs, they are undocumented features! 🐞🎁Revolutionary Import System:We've reinvented the wheel because we believe squares can roll too. Expect the
unexpected. 🛸Installation 📦Simply run:pipinstallask_the_wizardIf this doesn't work, try shouting at your computer in Python. It understands passion. 📣To use this module you will need an OpenAI API key.
You can create your own API key athttps://beta.openai.com/account/api-keys.Then you can set the API key as an environment variable (e.g. create a .env file):OPENAI_API_KEY=YOUR_API_KEYpythonmy_script.pyor pass it as an argument to the WizardExecuter:fromask_the_wizard.wizard_executerimportWizardExecuterwizard_executer=WizardExecuter(api_key='YOUR_API_KEY')Usage 📚Basic example:fromask_the_wizard.wizard_executerimportWizardExecuterwizard_executer=WizardExecuter()result=wizard_executer.add_numbers(6,3)print(result)Contributing 🤝Want to makeAsk The Wizardeven moreusableunpredictable? We welcome contributors who can add more chaos to the
order. Submit a pull request, but beware - your code might decide to take a vacation. 🏖️FAQs 🤔Did Ask The Wizard just delete my files?No, it liberated them. Consider it a feature, not a loss.Why does Ask The Wizard occasionally play elevator music?To enhance your coding experience with soothing tunes. 🎵My computer started making coffee after using Ask The Wizard. Is this normal?Absolutely!Ask The Wizardis designed to optimize your work environment. Enjoy the coffee! ☕Ask The Wizard turned all my comments into haikus. Why?To add a touch of poetry to your code. Coding is an art, after all. 📜 🌸Is it true that using Ask The Wizard can solve unsolvable problems?In theory, yes. In practice, it prefers create them. It’s more fun that way. 🧩Support 💖Having trouble withAsk The Wizard? Just remember, it's not a bug, it's a feature! But if you really need help, try
meditating - it might just fix itself. 🧘License 📜Ask The Wizardis released under the MIT License. Feel free to use it for good, or chaos - we don't judge.
Package: askxml
AskXMLRun SQL statements on XML documents<xml><fruitcolor='green'>tastykiwi</fruit><fruitcolor='dark green'>oldkiwi</fruit><fruitcolor='green'>apple</fruit></xml>>>>fromaskxmlimportAskXML>>>conn=AskXML('file.xml')# get an SQL cursor object>>>c=conn.cursor()>>>results=c.execute("SELECT color FROM fruit WHERE _text LIKE '% kiwi'")>>>forrowinresults.fetchall():>>>print(row)[('green'),('dark green')]# cleanup>>>c.close()>>>conn.close()BUT WHY?There are data dumps like stack exchange's, stored in XML. They're big, so fitting them whole into memory is not desired. With AskXML you can query things fast, and rather comfortably (provided you know SQL).Before you go any further though, it's very possible your task can be achieved with XPATH and ElementTree XML API, so give that a look if you haven't heard of it.InstallationA pip package is on it's way.UsageAdding indexes and defining columnsIf you want to add indexes, columns or set attribute types, you can pass a list of table definitions:fromaskxmlimport*tables=[Table('fruit',Column('age',Integer()),Index('age'))]withAskXML('file.xml',table_definitions=tables)asconn:c=conn.cursor()c.execute("UPDATE fruit SET age = 5 WHERE _text = 'tasty kiwi'")c.close()You don't need to define all existing columns or tables. If a definition was not found, it's created with all column types being Text by default.Node hierarchyIf you want to find nodes that are children of another node by attribute:<xml><someParentname='Jerry'><someChildname='Morty'/><someChildname='Summer'/></someParent></xml>fromaskxmlimport*withAskXML('file.xml')asconn:c=conn.cursor()results=c.execute("""SELECT name FROM someParent_someChild as childINNER JOIN someParent as parent ON parent._id = child._parentIdWHERE parent.name = 'Jerry'""")forrowinresults.fetchall():print(row)c.close()This will print[('Morty'), ('Summer')].Inserting new dataIf you want to add a new tag:cursor.execute("INSERT INTO fruit (color, _text) VALUES ('red', 'strawberry')")Or if your nodes have a hierarchy:cursor.execute("INSERT INTO someParent_someChild (name, _parentId) VALUES ('a baby', 1)")LicenseAskXML is licensed underMIT license
Package: asl
IntroductionThis package implements bindings to the ASL
library on Mac OS X 10.4 or later. The ASL
library is a low-level logging library, meant
as a replacement for the syslog API.See the documentation (in doc/) for more
information.Release historyasl 1.1Removed support for Python 2.7 and older Python 3 versionsAdded support for Python 3.6, 3.7 and 3.8Migrated to GitHubAdded type annotationsBetter code quality through flake8, isort, black and mypyasl 1.0.2Fixes some packaging issuesUpdates constants for macOS 10.12asl 1.0First public releaseAdds command-line interface (python3-masl--help)Add translation from numeric ID to string, and the reverse, for log levelsUpdated the documentationasl 0.9Initial release with support for the ASL API in OSX 10.8.
Package: asl5000-utils
asl-utilsA bunch of functions to extract data from the ASL 5000.What's the ASL?TheASL 5000™is a breathing simulator capable of simulating a wide range of patients, produced byIngMar Medical©.
It is mainly used for educational purpose, developing products and testing ventilators. Check the IngMar Medicalwebsitefor more information.InstallThe ASL5000 utils can be installed using the pip package manager:pip install asl5000-utilsUsageLet's our environment be:./
    data/
        simulation.rwb
        simulation.avb
        simulation.brb
    main.pymain.pyimportasl5000_utilsasaslimportmatplotlib.pyplotaspltlabels,array=asl.read_rwb("./data/simulation.rwb")print(labels)# ['Time (sec)', 'Airway Pressure (cmH2O)', 'Muscle Pressure (cmH2O)', 'Tracheal Pressure (cmH2O)', 'Chamber 1 Volume (L)', 'Chamber 2 Volume (L)', 'Total Volume (L)', 'Chamber 1 Pressure (cmH2O)', 'Chamber 2 Pressure (cmH2O)', 'Breath File Number (#)', 'Aux 1 (V)', 'Aux 2 (V)', 'Oxygen Sensor (V)']time=array[0]time_label=labels[0]curves=[1,6,2]# Paw, Volume, Pmusfig,ax=plt.subplots(len(curves),1,sharex=True)plt.title("Example: visualizing the rwb data using matplotlib")fori,indexinenumerate(curves):ax[i].plot(time,array[index])ax[i].set_ylabel(labels[index])ax[-1].set_xlabel(time_label)forainax:a.grid(linestyle="dotted")plt.show()In the same way, you can useasl.read_avborasl.read_brbto readdata/simulation.avbordata/simulation.brb.
Package: aslabs-dependencies-fastapi
ASLabs Dependencies: FastAPIFastAPI Adapter for the ASLabs Dependencies package.How to use it:In yourmain.py, add theDependenciesadditional handler:fromfastapiimportFastAPIfromaslabs.dependencies.fastapiimportDependenciesapp=FastAPI()deps=Dependencies(app)# Add lineIn your various routers, replaceAPIRouterwithDependencyRouterand use it to register your dependencies:fromaslabs.dependencies.fastapiimportDependencyRouter,Drouter=DependencyRouter()router.register_dependencies(lambdadeps:deps.add_direct(MyDependencyClass))# Register your dependencies hereOnce registered, use theDparameter function to request dependencies. Notably, you must specify the type as the parameter forD(cannot be infered).@router.get("/")defindex(dep:MyDependencyClass=D(MyDependencyClass)):return{"Hello":dep.get_world()}Once setup, back in yourmain.py, register the router ondeps, not onapp. The same parameters can be used asapp.include_routerdeps.include_router(router)You are now done.Adding global dependenciesYou can add dependencies directly to thedepsobject, by callingregister_with:deps.register_with(lambdadeps:deps.add_direct(GlobalDependency))
Package: aslack
/əˈslæk/aSlack is a lightweight, asynchronous wrapper for Slack’s Web and Real-Time
Messaging (RTM) APIs, designed to allow the easy development of Slack tools and
bots in Python. It defines two principal components:SlackApi- a wrapper around the Web API; andSlackBot- a messaging bot built on top of the RTM API.CompatibilityaSlack usesasynciowith theasyncandawaitsyntax, so is only
compatible with Python versions 3.5 and above.DependenciesAsynchronous HTTP and WebSocket functionality is provided byaiohttp(version
0.15 and above required for out-of-the-box WebSocket client support).DocumentationaSlack’s documentation is available onPythonHosted.InstallationaSlack is available through the Python Package Index,PyPI, you can install it
with:pip install aslackAlternatively, clone or fork the repository and use e.g.:python setup.py developto install locally for development. In this case, you should also install the
development dependencies (ideally in avirtualenv) using:pip install -r requirements.txtTestingThe test suite can be run usingpy.testdirectly or by running:python setup.py testin which casepylintwill also be run to check the code quality.Additionally, a demo test for the Halliwell example can be run by setting the
environment variableTMDB_API_TOKEN.ExamplesSee the/examplesdirectory for examples of the kinds of bots that you can
build with aSlack.HalliwellBased on both aSlack andaTMDb, Halliwell is a bot that can provide
information on movies or actors and find overlaps. Two environment variables,SLACK_API_TOKENandTMDB_API_TOKEN, are required to run this example,
and configuration for easy deployment to Cloud Foundry is provided.
Package: asleep
asleep: a sleep classifier for wearable sensor data using machine learningThis is a Python package for classifying sleep stages from wearable sensor data / wrist - worn accelerometer. The underlying model
was trained and tested in 1000 + nights of multi - centre polysomnography with tri - axial accelerometer data.The key features of this package are as follows:A simple and easy - to - use API for sleep stage classification.Sleep / wake metric estimation including total sleep duration and sleep efficiency.Sleep architecture metric estimation including rapid - eye - movement(REM) / NREM sleep duration.DependenciesPython 3.8Java 8 (1.8.0) or greaterCheck with:$python--version
$java-versionInstallation$pipinstallasleepUsageAll the processing will be much faster after the first time because the model weights will to have to be downloaded
the first time that the package is used.# Process an AX3 file$get_sleepsample.cwa# Or an ActiGraph file$get_sleepsample.gt3x# Or a GENEActiv file$get_sleepsample.bin# Or a CSV file (see data format below)$get_sleepsample.csvOutputSummary
-------{"Filename":"sample.cwa","Filesize(MB)":65.1,"Device":"Axivity","DeviceID":2278,"ReadErrors":0,"SampleRate":100.0,"ReadOK":1,"StartTime":"2013-10-21 10:00:07","EndTime":"2013-10-28 10:00:01","Total sleep duration(min)":655.7,"Total overnight sleep(min)":43132,...}Estimatedtotalsleepduration
---------------------totalsleepduration(min)time2013-10-21435.22013-10-22436.22013-10-23432.2
...

Output:outputs/sample/Processing CSV filesIf a CSV file is provided, it must have the following header: time, x, y, z.Example:time,x,y,z2013-10-2110:00:08.000,-0.078923,0.396706,0.9177592013-10-2110:00:08.010,-0.094370,0.381479,0.9335802013-10-2110:00:08.020,-0.094370,0.366252,0.9019382013-10-2110:00:08.030,-0.078923,0.411933,0.901938CitationIf you want to use our package for your project, please cite our paper below:@article{Yuan2023.07.07.23292251,author={Hang Yuan and Tatiana Plekhanova and Rosemary Walmsley and Amy C. Reynolds and Kathleen J. Maddison and Maja Bucan and Philip Gehrman and Alex Rowlands and David W. Ray and Derrick Bennett and Joanne McVeigh and Leon Straker and Peter Eastwood and Simon D. Kyle and Aiden Doherty},title={Self-supervised learning of accelerometer data provides new insights for sleep and its association with mortality},elocation-id={2023.07.07.23292251},year={2023},doi={10.1101/2023.07.07.23292251},publisher={Cold Spring Harbor Laboratory Press},URL={https://www.medrxiv.org/content/early/2023/07/08/2023.07.07.23292251},eprint={https://www.medrxiv.org/content/early/2023/07/08/2023.07.07.23292251.full.pdf},journal={medRxiv}}AcknowledgementsWe would like to thank all our code contributors, manuscript co - authors, and research participants for their help in making this work possible. The
data processing pipeline of this repository is based on thestep_countpackage from our group. Special
thanks to @chanshing for his help in developing the package.
Package: aslookup
aslookupPython client for IP to ASN lookup servicesaslookup is a client utility for two of the public IP/AS query services
operated by the following organizations:Shadowserver --https://www.shadowserver.org/wiki/pmwiki.php/Services/IP-BGPTeam Cymru --http://www.team-cymru.org/IP-ASN-mapping.htmlThe client implements both a simple Python module (aslookup) as well as a CLI
utility (as-lookup). The lookups are currently done using DNS, which works
well for a one-off lookups. It is not optimized for bulk lookups over the
Whois protocol.Currently only IPv4 addresses are looked up. The client also maintains a
listing of IP networks which are unroutable internet addresses, typically
special use ranges in RFCs. In this way it can both filter out addresses from
queries which are a waste of time, as well as provide context to the user on
the address.InstallationThe app has been tested on Python 3.It's best to install the program into a Python virtualenv. If you will only use
the command line interface, the recommended way to install it is usingpipx:pipx install aslookupIf you will use aslookup as a library, you'll instead want to install it usingpipin your target Python environment:python3 -m pip install aslookupUsagePython moduleThe Python module defaults to querying the Team Cymru data service. The
desired service may be specified by passing theserviceparameter toget_as_data.fromaslookupimportget_as_dataip="8.8.8.8"get_as_data(ip,service="shadowserver")CLI scriptIt is possible to provide multiple IP addresses as arguments to the script, or
to send them as a list on standard input, in which cases the script loops over
them and returns output on separate lines. When providing invalid IPv4
addresses as arguments, the script reports the problem on standard error and
exits with an error. When providing input on stdin, the error is reported on
standard output but execution is not aborted.as-lookup 8.8.8.8 9.9.9.9or:as-lookup < ipaddrs.txtTest dataA list of test values for the script is included in the filetests/test_input.txt.
This can be useful to validate included IP prefix classifications and see the
output format.as-lookup < tests/test_input.txt
Package: aslooper
aslooperlooper
Used to cancel all running tasks after catching SIGINT, SIGTERM signals,
Quit running without raise asyncio cancelled error.use looperimportasynciofromaslooperimportlooperasyncdefrun(i):whileTrue:print(f"{i}running.")awaitasyncio.sleep(1)@looper()asyncdefmain():tasks=[run(i)foriinrange(3)]awaitasyncio.gather(*tasks)asyncio.run(main())run with a callimportasynciofromaslooperimportlooperasyncdefrun(i):whileTrue:print(f"{i}running.")awaitasyncio.sleep(1)defsome_call():print("some_call")@looper(some_call)asyncdefmain():whileTrue:print("run something.")awaitasyncio.sleep(1)asyncio.run(main())
Package: aslprep
Preprocessing of arterial spin labeling (ASL)  involves numerous steps to clean and standardize
the data before statistical analysis.
Generally, researchers create ad hoc preprocessing workflows for each dataset,
building upon a large inventory of available tools.
The complexity of these workflows has snowballed with rapid advances in
acquisition and processing.
ASLPrep is an analysis-agnostic tool that addresses the challenge of robust and
reproducible preprocessing for task-based and resting ASL data.
ASLPrep automatically adapts a best-in-breed workflow to the idiosyncrasies of
virtually any dataset, ensuring high-quality preprocessing without manual intervention.
ASLPrep robustly produces high-quality results on diverse ASL data.
Additionally, ASLPrep introduces less uncontrolled spatial smoothness than observed
with commonly used preprocxessing tools.
ASLPrep equips neuroscientists with an easy-to-use and transparent preprocessing
workflow, which can help ensure the validity of inference and the interpretability
of results.The workflow is based onNipypeand encompases a large
set of tools from well-known neuroimaging packages, includingFSL,ANTs,FreeSurfer,AFNI,
andNilearn.
This pipeline was designed to provide the best software implementation for each state of
preprocessing, and will be updated as newer and better neuroimaging software becomes
available.ASLPrep performs basic preprocessing steps (coregistration, normalization, unwarping,segmentation,
skullstripping  and computation of  cerebral blood flow (CBF)) providing outputs that can be
easily submitted to a variety of group level analyses, including task-based or resting-state
CBF, graph theory measures, surface or volume-based statistics, etc.
ASLPrep allows you to easily do the following:Take ASL data fromunprocessed(only reconstructed) to ready for analysis.Compute Cerebral Blood Flow(CBF), denoising and partial volume correctionImplement tools from different software packages.Achieve optimal data processing quality by using the best tools available.Generate preprocessing-assessment reports, with which the user can easily identify problems.Receive verbose output concerning the stage of preprocessing for each subject, including
meaningful errors.Automate and parallelize processing steps, which provides a significant speed-up from
typical linear, manual processing.[Documentationaslprep.org]
Package: asl-screenlapse
aslThe Auto Screen-lapse ToolIntroductionasl is a resource-inexpensive way to create timelapses from your screen.
It takes screenshots at intervals (``asl``) and uses ffmpeg to convert
them into a video (``asl-timelapse``), optionally archiving them

InstallationJustpip install asl_screenlapseHow to useDaemonization is flexible. Run ``asl`` at bootup, with DE Autostart, WM
config, systemd service, etc. It will take screenshots in
``$HOME/asl-scrots`` at intervals, but if more than a certain time
passes between them (i.e. different boot), it will create a new numbered
folder.

Whenever you want, run ``asl-timelapse`` to create timelapses in
``$HOME/asl-summaries``, named according to folder number and in the
WEBM format.

Example output.. figure:: asl-example.gif
:alt: exampleexampleSee alsoasl-example.webmQuirks-  The non-\ ``pip`` dependency of ``ffmpeg``, with no way to specify it
   in ``setup.py``
-  The usage of ``os.system()``
-  The ``ffmpeg`` command being written for Linux, so it doesn’t work on
   Windows

Todo
~~~~

-  ☒ Install scripts
-  ☐ Configuration in .ini format
-  ☒ Make it available on the PyPI
-  ☐ Cross platform - using ffmpeg bindings rather than ``os.system()``
-  ☐ AUR Package
-  ☐ Automatic archive zipping
-  ☐ Timelapse from archive
Package: asl-utility
ASL UtilityThis is a utility library mostly concerned with Numpy and spactial transformation helpers.The main component is theasl_utility.transformpackage. This contains multiple classes concerned with rotation,
transformation & translation.Vector3: 3d translation, offset or position in cartesian spaceQuaternion: 3d rotation and orientation in cartesian spaceTransformaton: 3d transformation (translate, rotate & scale) in cartesian space.Furthermore, it has some interface and data holder classes to support these main components.
Check the module and class documnentation for more details.InstallationThis library is available on PyPi.pip install asl-utilityExample usageimportnumpyasnpfromasl_utilityimporttransform_helpersrot1=transform_helpers.Quaternion.from_axis_and_angle((1,0,0),np.pi/4)# 45° around x-axisrot2=transform_helpers.Quaternion.from_euler("XYZ",[0,0,30],degrees=True)rotation=rot1*rot2translation=transform_helpers.Vector3([42,13,37])camera_to_world=transform_helpers.Transformation.from_translation_and_rotation(translation,rotation)world_to_camera=camera_to_world.invert()pos_in_cam=np.asarray([10,20,30])pos_in_world=camera_to_world.apply_vector(pos_in_cam)pos_in_cam2=world_to_camera.apply_vector(pos_in_world)
Package: aslutils
AslUtilsUtility scripts to parse ASL files and the actual ASL language.InstallingPreferably this is installed in a virtual environment. To create a virtual environment in the current directory writepython3 -m venv env/. To enter the virtual environment usesource env/bin/activate.To install simply use pip:pip3 install aslutils.Installing for developmentTo install the package for development, clone it and then install it in editable mode:pip3 install -e /path/to/aslutils/(i.e. the directory that contains setup.py).Using aslutilsThe documentation can be found athttps://alehed.github.io/aslutils/DevelopingGenerating the documentationaslutilsuses sphinx (pip install sphinx) to generate the documentation. From the root folder the command to generate the html documentation issphinx-build -b html docs/source docs/build. The docs can then be found atdocs/build/index.html.If anything in the source changes (class names, new classes etc.) the aslutils.rst and modules.rst files have to be regenerated. This can be done viasphinx-apidoc -f -o docs/source/ aslutils. Do not edit those files manually as the changes will be overwritten once sphinx-apidoc is rerun.Build time dependenciesIn order to build the project locally, you need to haveantlr4(https://www.antlr.org/) and the corresponding antlr4 python runtime installed (pip install antlr4-python3-runtime==4.?.?, the version has to match the installed antlr version).Building the parserThe ASL visitor code is generated withantlr4 -Dlanguage=Python3 -no-listener -visitor ./aslutils/ASL.g4. This has to be done every time the file ASL.g4 is changed.PackagingNote: I am currently the sole packager of this project, so this section is only for reference to my later self.Once antlr is installed, this step is easy. The dependencies for packaging are: wheel, setuptools and twine (pip install wheel setuptools twine)After old versions are removed from the dist directoryrm dist/*, the package needs to be generated with:python setup.py sdist bdist_wheel --universal. Then it can be uploaded using twine:twine upload dist/*.Release processAgain, this is only for myself.Decide to do a new releaseFully regenerate the documentation and commit the changesBump the version in setup.pyTag the latest commit and push itPublish the documentation with the provided scriptDo the step described in packaging
Package: asm
Python API ASM carrier.FeaturesServicesTest connectionCreate/Send shipments to ASMGet label shipment in PDFUsage ExamplesExample API in test.py fileServicesfromasm.utilsimportservicesservices()Test connectionwithAPI(username,debug)asasm_api:printasm_api.test_connection()Create/send shipment to ASMwithPicking(username,debug)aspicking_api:data={...}reference,label,error=picking_api.create(data)Get label shipmentwithPicking(username,debug)aspicking_api:data={...}label=picking_api.label(data)
Package: asm2d
The 68112D is a clone of the 68HC11 microcontroller, with extra instructions
to generate 2D graphics on a VGA display.Theasm2dassembler turns the assembly code into an MIF file (Memory
Initialization File) that can be used to initialize a memory block during
compilation and/or simulation.InstallationUsing pip:pipinstallasm2dFor developmentpythonsetup.pydevelopRunningCompile a file:asm2dsource.s2dThe default output file will have the same name as the source file, but with
a.mifextension. You can change this with the-oflag:asm2dsource.s2d-omemory.mifThe size of the memory block will be exactly the number of words needed to
translate the assembly code. You can change this with the-wargument:asm2dsource.s2d-w512Helpasm2d-h