Saravanan666/pypi-org huggingface dataset:
Package: qudi-core
qudi-coreThe qudi-core repository represents the base installation for thequdiPython package.It provides a versatile framework for modular multi-instrument and multi-computer measurement
applications.
It enables scientists and engineers to easily develop specialized multithreaded graphical or
non-graphical applications.Most of the more technical details about a complex measurement suite are handled automatically byqudiso the developer can focus on what matters most... the measurement control logic and the
optional graphical user interface.An incomplete list of functionalityqudiprovides:loggingthread managementautomatic app status dumping/loadingruntime resource managementbase modules for hardware interfaces, measurement logics and graphical user interfacesinter-module communicationsupport for installablequdinamespace package addonsinteractive local IPython kernel interfacehigh-level automation framework via tasks/scriptsmeasurement setup configuration via YAML config filevarious tooling as a Python librarybasic data storage facility...AttributionIf you are publishing any work based on using qudi as a framework/tool it is good practice to
mention the qudi project, e.g. in the methods description.Even better, you could simply cite our initial publication about qudi:Qudi: A modular python suite for experiment control and data processingThe qudi contributors will appreciate this and it helps our open-source community to gain attention.
This will hopefully attract more people willing to help in improving the qudi project which in turn
benefits everyone using this software.Thank you!InstallationFor installation instructions please refer to ourqudi installation guide.DocumentationThe official qudi documentation homepage can be foundhere.ForumFor questions concerning qudi on any level, there is aforumto discuss with the qudi community. Feel free to ask!
If you found a bug and located it already, please note GitHub'sissue trackingfeature.ContributingYou want to contribute to the qudi project? Great! Please start by reading through ourcontributing guideline.To file a bug report or feature request please open anissue on GitHub.To contribute source code to the qudi-core repository please open apull request on GitHub.Issuesandpull requestsshould be discussed openly in their
respective comment sections on GitHub.For any other development-related questions or discussions please subscribe to and use ourqudi-dev mailing list. Please also consider usinggiststo showcase and discuss topics publicly within the qudi community.News and UpdatesWe will occasionally inform the qudi community about releases and breaking changes (no discussions).If you are using qudi and want to stay in the loop, please subscribe to ourqudi-announce mailing list.LicenseQudi is licensed under theGNU Lesser General Public License Version 3 (LGPL v3).A copy of the full license text can be found in the repository root directory inLICENSEandLICENSE.LESSERFor more information please check thelicense section in the qudi documentation.CopyrightCheckAUTHORS.mdfor a list of authors and the git history for their individual
contributions.
Package: qudida
QuDiDA (QUick and DIrty Domain Adaptation)QuDiDA is a micro library for very naive though quick pixel level image domain adaptation viascikit-learntransformers.
Is assumed to be used as image augmentation technique, while was not tested in public benchmarks.Installationpip install qudidaorpip install git+https://github.com/arsenyinfo/qudidaUsageimport cv2

from sklearn.decomposition import PCA
from qudida import DomainAdapter

adapter = DomainAdapter(transformer=PCA(n_components=1), ref_img=cv2.imread('target.png'))
source = cv2.imread('source.png')
result = adapter(source)
cv2.imwrite('../result.png', result)ExampleSource image:Target image (style donor):Result with various adaptations:
Package: qudi-iqo-modules
qudi-iqo-modulesA collection of qudi measurement modules originally developed for experiments on color centers in
semiconductor materials.InstallationFor installation instructions please refer to ouriqo-modules installation guide.More informationThe best starting point for further researching the qudi documentation is thereadme fileof the qudi-core repo.ForumFor questions concerning qudi or the iqo-modules, there is aforumto discuss with the qudi community. Feel free to ask!
If you found a bug and located it already, please note GitHub'sissue trackingfeature.CopyrightCheckAUTHORS.mdfor a list of authors and the git history for their individual
contributions.
Package: qudit-sim
qudit-sim: Qudit pulse simulation and effective Hamiltonian analysisY. Iiyamaqudit-simis a tool for extracting effective Hamiltonians / gate unitaries of arbitrary microwave pulses applied to a system of statically coupled d-level quantum oscillators (qudits). Its intended usage is as a base for prototyping new pulse sequences that implement custom quantum gates involving more than two oscillator levels.Most of the heavy-lifting is done byQuTiPthrough its Schrodinger equation solver (sesolve). The main functions of this tool are to prepare the Hamiltonian object passed tosesolvefrom the input parameters, and to interpret the result of the simulation.As the focus of the tool is on prototyping rather than performing an accurate simulation, the tool currently assumes a simple model of the system. In particular, incoherent effects (qudit relaxation, depolarization, etc.) are not considered.InstallationMost recent tagged versions are available in PyPI.pip install qudit-simTo install from source,git clone https://github.com/UTokyo-ICEPP/qudit-sim
cd qudit-sim
pip install .RequirementsExact versions of the required packages have not been checked, but reasonably recent versions should do.numpyscipyqutiph5pymatplotlibjax: If using the fidelity maximization (default) method for the effective Hamiltonian extractionoptax: If using the fidelity maximization (default) method for the effective Hamiltonian extractionrqutilsDocumentation and examplesThe documentation including the mathematical background of the simulation and effective Hamiltonian extraction is available atRead the Docs.Example analyses using qudit-sim are available as notebooks in theexamplesdirectory.ContributeYou are most welcome to contribute to qudit-sim development by either forking this repository and sending pull requests or filing bug reports / suggestions for improvement at theissues page.
Package: qudotpy
QuDotPy=======A quantum computing library written in Python. Exploring quantum computing has never been easier. With QuDotPy you canexperiment with single-qubit operations and gates. You can build multiple-qubit states and perform measurements, and finally you can emulate quantum circuits.To help you get started we have written a detailed usage tutorial that covers most aspects of QuDotPy. The tutorial can be found here: <a href="http://www.sakkaris.com/tutorials/qudotpy.html" target="_blank">QuDotPy Tutorial</a>QuDotPy depends on Numpy. You will need to have Numpy installed before you can use QuDotPy.Getting Started===============QuDotPy depends on Python 3 and is specifically tested against Pythong 3.6.5You can test by running the unit tests in the parent qudotpy directory```python -m unittest qudotpy.test_qudotpy``````$ python>>> from qudotpy import qudot>>> print qudot.apply_gate(qudot.H, qudot.ZERO)(0.707106781187+0j)|0> + (0.707106781187+0j)|1>>>>```That's it! For more check out our tutorial: <a href="http://www.sakkaris.com/tutorials/qudotpy.html" target="_blank">QuDotPy Tutorial</a>
Package: qudra
qudraQuantum Energy ManagementMotivationLeveraging quantum advantage to distributed grids for energy security and sustainability.Please check out these slides for moreinformation.InstallationOur team's contribution is supposed to go into thequdrafolder. So move therecd qudraConda users, please make sure toconda install pipbefore running any pip installation if you want to installqudrainto your conda environment.qudrais published on PyPI. So, to install, simply run:pipinstallqudraIf you also want to download the dependencies needed to run optional tutorials, please usepip install qudra[dev]orpip install 'qudra[dev]'(forzshusers).To check if the installation was successful, run:>>>importqudraBuilding from sourceTo buildqudrafrom source, pip install using:gitclonehttps://github.com/Q-Energy-2022/qudra.gitcdqudra
pipinstall--upgrade.If you also want to download the dependencies needed to run optional tutorials, please usepip install --upgrade .[dev]orpip install --upgrade '.[dev]'(forzshusers).Installation for DevsIf you intend to contribute to this project, please installqudrain editable mode as follows:gitclonehttps://github.com/Q-Energy-2022/qudra.gitcdqudra
pipinstall-e.[dev]python3 -m venv venv
. venv/bin/activate
Please usepip install -e '.[dev]'if you are azshuser.Building documentation locallySet yourself up to use the[dev]dependencies. Then, from the command line run:mkdocsbuildThen, when you're ready to deploy, run:mkdocsgh-deployAcknowledgementsCore Devs:Asil Qraini,Fouad Afiouni,Gargi Chandrakar,Nurgazy Seidaliev,Sahar Ben Rached,Salem Al Haddad,Sarthak Prasad MallaMentors:Akash Kant,Shantanu JhaThis project was created at the2022 NYUAD Hackathonfor Social Good in the Arab World: Focusing on Quantum Computing (QC).
Package: qudth
Qudth randomly samples the lines within a large file and calculates statistics
about each line. For example, in a 10-gigabyte text file, you might want to know
how long a typical line is.Line lengthsIt would be very convenient if line length is what you are interested in, as
that is the only thing we implement right now.$ qudth qudth/cli.py -n 5 --bins 8

▁ ▁ ▂ ▁ ▁ ▁ ▃ ▃
01     52     59
Lengths of 5 lines in qudth/cli.py
(simple random sample with replacement)Benchmarkingwc-lis equivalent to qudth’s line length estimation,
but qudth’s sampling makes it much faster
on large files.big-file.csvis 1 gigabyte in size._:~ t$ time qudth big-file.csv > /dev/null

real    0m0.287s
user    0m0.161s
sys     0m0.032s
_:~ t$ time wc -l big-file.csv > /dev/null

real    0m2.515s
user    0m1.475s
sys     0m0.440sFuture workA more standard thing would perhaps be something that emitted
a random sample to stdout. It could support different sampling
strategies perhaps.
Package: que
Slice and dice html on the command line using CSS selectors.Quick startLet’s say you want to grab all the links onhttp://example.com/foo/bar:$ curl http://example.com/foo/bar | que "a->href"Let’s say that gave you 3 lines that looked like this:/some/url?val=1
/some/url2?val=2
/some/url3?val=3Ugh, that’s not very helpful, so let’s modify our argument a bit:$ curl http://example.com/foo/bar | que "a->http://example.com{href}"Now, that will print:http://example.com/some/url?val=1
http://example.com/some/url2?val=2
http://example.com/some/url3?val=3SelectingNot sure how to use CSS Selectors?Beautiful Soup CSS select
docsJQuery’s CSS Selector
docsThe selector is divided into two parts separated by->, the first
part is the traditional selector talked about in the above links and the
second part is the attributes you want to print to the screen for each
match:$ css.selector->attribute,selectorThe Selector part usesPython’s string formatting
syntaxso
you can embed the attributes you want within a larger string.ExamplesFind all the “Download” links on a page:que has support for the the non-standard:contains css
selector$ curl http://example.com | que "a:contains(Download)->href"Select all the links with attributedatathat starts with “foo”:$ curl http://example.com | que "a[data|=foo]->href"InstallationYou can use pip to install stable:$ pip install queor the latest and greatest (which might be different than what’s onpypi:$ pip install git+https://github.com/jaymon/que#egg=queNotesIf you need a way more fully featured html command line parser, tryhq.
Package: queasars
QUEASARS - Quantum Evolving Ansatz Variational SolverQUEASARS is an open-source, qiskit-based, python package implementing quantum variational eigensolvers which use evolutionary algorithms to find a good ansatz during the optimization process, likeE-VQE,MoG-VQEorQNEAT.Table of contentsInstallationUsageContributingMaintainersCopyright and licensesCopyrightLicenseInstallationUsing PipQUEASARS requires a python3 environment with python >= 3.9 and can be installed using the following pip command:pip install queasarsFrom SourceQUEASARS' development dependencies are managed usingpoetry.
To install QUEASARS from source follow these instructions:Clone the QUEASARS repository.Install Python 3.11Install poetry (installation guide).Runpoetry installfrom within QUEASARS' project directory to install its dependencies.UsageContributingContributions to this project are welcome. You may open issues, fix or expand documentation, provide new functionality or create more and better tests. If you have a minor contribution you can open a pull request right away. For any major contribution please open an issue first or discuss with the repository maintainer. Please also note that you need to fill out and sign acontributor license agreementMaintainersThe current Maintainers of QUEASARS areSven Prüfer (@svenpruefer)andDaniel Leidreiter (@dleidreiter).Copyright and licenseCopyrightQuantum Evolving Ansatz Variational Solver (QUEASARS)Copyright 2023 DLR - Deutsches Zentrum für Luft- und Raumfahrt e.V.This product was developed at DLR - GSOC (German Space Operations Center at the German Aerospace Center DLR,https://www.dlr.de/).LicenseQUEASARS is licensed under theApache License, Version 2.0.
Package: queclinkdoc
Queclinkdoc is a simple, clean, and less-configured theme for theSphinxdocumentation system developed byQueclink Wireless Solutions Co., Ltd.We show the globalTOCtree of the documentation in a drop-down list at the head of the page, and even if you browse to the end of the page, this TOC tree will still be fixed at the head, so you can jump to other pages at any time.We recommend usingGoogle ChromeorFirefoxto read the generated documentation.You can make and installqueclinkdoctheme like this:pysetup.pysdistpy-mpipinstalldist\queclinkdoc-x.x.tar.gzWhen using therefdirective to jump to the top of the page, for a good experience, please name the label at the top of the page withheadlabel-as a prefix, for example:1 .. _headlabel-page-title:
2
3 Page Title
4 ===========
5In addition, this theme supports the following custom HTML options:toc_background_colorUsed to specify the background color of the title area at the head of the page, the default is Blue (#2B579A), for example, you can change it to Green like this:html_theme_options = {
  'toc_background_color': '#008080',
}zoomout_asizeCan betrueorfalse, default istrue. The font size of the <a> tag whose first character is a capital letter will be reduced to 0.95em when it is true, and will not be reduced when it is false. You can change it to false like this:html_theme_options = {
  'zoomout_asize': 'false',
}snapshot.pngis a snapshot of thequeclinkdoctheme.If you have any questions or suggestions, please contact us, thanks in advance.
Package: quecto
quecto-pyQuecto-py is a simple and official wrapper of Quecto, an open-source and self-hostable solution for link shortening.InstallationpipinstallquectoUsageShorten a linkfromquectoimportQuectoclient=Quecto("https://s.oriondev.fr")r=client.shortUrl("https://example.com","password")# password is optionalprint(r)# https://s.oriondev.fr/s/189d28e9b9ae6Unshorten a linkfromquectoimportQuectoclient=Quecto("https://s.oriondev.fr")r=client.unshortUrl("https://s.oriondev.fr/s/189d28e9b9ae6","password")# password is optionalprint(r)# https://example.comCheck if the domain is a valid Quecto instancefromquectoimportQuectoclient=Quecto("https://s.oriondev.fr")r=client.isValidInstance()print(r)# TrueContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseGPL3
Package: queenbee
Queenbee :crown:Queenbee is a workflow language for describing workflows! The workflow Schema
is inspired byArgo Workflowand
borrows a number of terms and expressions fromApache AirflowandAnsible.Queenbee populates and validates the workflows but does not run them! For running the
workflows seeladybug-tools/queenbee-luigiwhich converts Queenbee workflows to executableLuigipipelines.You can find more workflow samples inhoneybee-radiance-workflowrepository.Installation> pip install queenbeeor if you want to use the CLI> pip install queenbee[cli]DocumentationYou can access the full docs for this package and its CLIhere.You can also access theSchema
Documentationand
OpenAPI documentation for:ObjectRedocOpenAPI JSONPluginredocjsonReciperedocjsonJobredocjsonLocal DevelopmentClone this repo locallygit clone git@github.com:ladybug-tools/queenbeeorgit clone https://github.com/ladybug-tools/queenbeeInstall dependencies:cd queenbeepip install -r dev-requirements.txtpip install -r requirements.txtRun Tests:python -m pytest tests/Generate Documentation:sphinx-apidoc-f-e-d4-o./docs/modules./queenbeesphinx-build-bhtml./docs./docs/_buildPreview Documentation:python -m http.server --directory ./docs/_build/Now you can see the documentation preview athttp://localhost:8000
Package: queick
QueickA simple inmemory job-queue manager for Python.FeatureWritten in Python only standard librariesJob-queue managerwithout redisWorking for low-spec machinesRetryRetry on network availableSchedulingInstallationPython version >= 3.6 is required.pip install queickUsageFirst, launch queick worker.$ queickSecond, prepare a job file (jobfunc.py) and an application (test.py).# jobfunc.pyimporttimedeffunction(arg):time.sleep(1)print(arg)# test.pyfromqueickimportJobQueuefromjobfuncimportfunctionfromtimeimporttimeq=JobQueue()q.enqueue(function,args=("hello",))q.enqueue_at(time()+5,function,args=("world",))# Run after 5 secondsst=SchedulingTime()st.every(minutes=1).starting_from(time.time()+10)q.cron(st,function,args=(1,2,))# Run after 10 seconds and every 1 minuteThird, run the application.$ python test.pyRetry on network availableJobs inside thefailed queuewill be dequeued when the network status changes from disconnected to connected.Some setups are needed to use the retry mode. First, launch queick worker with --ping-host options (details below).$ queick --ping-host asmsuechan.com # Please prepare your own ping server, do not use this.Second, pass an option to the method.q.enqueue(function,args=("hello",),retry_on_network_available=True)OptionsThere are some options for queick worker.namedefaultdescription-debugFalseif set, detailed logs will be shown--ping-hostNonehostname for NetworkWatcher to check if the machine has the internet connection--ping-port80port number for NetworkWatcher--log-filepathNonelogfile to save all the worker logAn example usage is below:$ queick -debug --ping-host asmsuechan.comTestingUnit test:$ python -m unittestIntegration test:$ docker build -t queick-test .
$ docker run --rm -it queick-test:latestDevelopmentBuild queick for development.$ python setup.py developDeploymentDeployed athttps://pypi.org/project/queick/.$ python setup.py sdist
$ twine upload dist/*
Package: quepland-bot
A simple library for recording and playing mouse macros at regular intervals between clicks.CompatibilityBuilt and tested on Ubuntu 21.04.Installationpip install quepland_botUsageImport and instantiate QueplandBotfrom quepland_bot import QueplandBot


bot = QueplandBot()Record clicks: once the method is called, it will wait for a space bar press to begin recording.
Press any kay to stop recording.bot.record_clicks()Play what you recorded until any key is pressed:bot.run()Changing intervals between clicksWhen instantiating QueplandBot you can define how many seconds it will take between clicks when playing a sequence.
Default is 0.1 seconds.bot = Queplandbot(default_seconds_between_clicks=0.5)Saving routinesYou can save a sequence of clicks by assigning the return ofrecord_clicks()to a variable.
To play it, pass it as an argument torun().
Whenrun()is called without arguments it runs last routine recorded.bot = QueplandBot()

one_routine = bot.record_clicks()
other_routine = bot.record_clicks()

bot.run(one_routine)
Package: quepy
__ _ _   _  ___ _ __  _   _
 / _` | | | |/ _ \ '_ \| | | |
| (_| | |_| |  __/ |_) | |_| |
 \__, |\__,_|\___| .__/ \__, |
    |_|          |_|    |___/What’s quepy?Quepy is a python framework to transform natural language questions to queries
in a database query language. It can be easily customized to different kinds of
questions in natural language and database queries. So, with little coding you
can build your own system for natural language access to your database.CurrentlyQuepyprovides support forSparqlandMQLquery languages.
We plan to extended it to other database query languages.An exampleTo illustrate what can you do with quepy, we included an example application to
accessDBpediacontents via theirsparqlendpoint.You can try the example online here:Online demoOr, you can try the example yourself by doing:python examples/dbpedia/main.py "Who is Tom Cruise?"And it will output something like this:SELECTDISTINCT?x1WHERE{?x0rdf:typefoaf:Person.?x0rdfs:label"Tom Cruise"@en.?x0rdfs:comment?x1.}ThomasCruiseMapotherIV,widelyknownasTomCruise,isan...The transformation from natural language to sparql is done by first using a
special form of regular expressions:person_name=Group(Plus(Pos("NNP")),"person_name")regex=Lemma("who")+Lemma("be")+person_name+Question(Pos("."))And then using and a convenient way to express semantic relations:person=IsPerson()+HasKeyword(person_name)definition=DefinitionOf(person)The rest of the transformation is handled automatically by the framework to
finally produce this sparql:SELECTDISTINCT?x1WHERE{?x0rdf:typefoaf:Person.?x0rdfs:label"Tom Cruise"@en.?x0rdfs:comment?x1.}Using a very similar procedure you could generate and MQL query for the same question
obtaining:[{"/common/topic/description":[{}],"/type/object/name":"Tom Cruise","/type/object/type":"/people/person"}]InstallationYou need to have installednumpy.
Other than that, you can just type:pip install quepyYou can get more details on the installation here:http://quepy.readthedocs.org/en/latest/installation.htmlLearn moreYou can find a tutorial here:http://quepy.readthedocs.org/en/latest/tutorial.htmlAnd the full documentation here:http://quepy.readthedocs.org/Join ourmailing listContribute!Want to help develop quepy? Welcome aboard! Find us in#quepy at freenodequepydev at librelist.com
Package: quera-ahs-utils
quera-ahs-utilsThis python package is a collection of tools that can be used to program QuEra'sneutral atom Analog Hamiltonian Simulator(ahs). These tools are primarily targeted towards the usage ofAmazon's Braket quantum computing service. The Braket Python SDK can be foundherealong with some examples of how to use their service through a collection of examples from bothBraketandQuEra.Some of the source code contained in this package originates fromthismodule which was co-authered by the Braket science team.We would be remiss not to advertise our ownJuliaSDK for programming QuEra'sahs,Bloqadeas well as modeling neutral atom quantum computing.InstallationThe package can be installed viapip:pip install quera-ahs-utilsPackage contentsquera-ahs-utilsis broken up into 5 modules each dealing with specific tools summarized in the table below:moduledescriptionquera_ahs_utils.analysisPerform analysis on shot resultsquera_ahs_utils.driveEasily generate different types of driving hamiltoniansquera_ahs_utils.irTransform between QuEra and Braket program representationsquera_ahs_utils.parallelizeTransform small jobs into a parallel set of jobs to maximize the field of view of the QPUquera_ahs_utils.plottingVisualize bothahsprograms as well as its results.A module reference can be foundhere