Saravanan666/pypi-org huggingface dataset:
Package: qoqo-pyquest
<img src=”qoqo_Logo_vertical_color.png” alt=”qoqo logo” width=”300” /># qoqo-pyquest[![Documentation Status](https://readthedocs.org/projects/qoqo_pyquest/badge/?version=latest)](https://qoqo_pyquest.readthedocs.io/en/latest/?badge=latest)
[![GitHub Workflow Status](https://github.com/HQSquantumsimulations/qoqo_pyquest/workflows/ci_tests/badge.svg)](https://github.com/HQSquantumsimulations/qoqo_pyquest/actions)
[![PyPI](https://img.shields.io/pypi/v/qoqo_pyquest)](https://pypi.org/project/qoqo_pyquest/)
![PyPI - License](https://img.shields.io/pypi/l/qoqo_pyquest)
[![PyPI - Format](https://img.shields.io/pypi/format/qoqo_pyquest)](https://pypi.org/project/qoqo_pyquest/)This PyQuEST interface for the [qoqo](https://github.com/HQSquantumsimulations/qoqo) quantum toolkit by [HQS Quantum Simulations](https://quantumsimulations.de) is deprecated, please use [qoqo-quest] (https://github.com/HQSquantumsimulations/qoqo-quest) instead.PyQuEST interface for the [qoqo](https://github.com/HQSquantumsimulations/qoqo) quantum toolkit by [HQS Quantum Simulations](https://quantumsimulations.de).qoqo-pyquest provides the PyQuestBackend class that allows users to simulate a qoqo circuit.
The PyQuestBackend can be uses together with the Measurement or DoUnitary classes of qoqo for automated observable measurements.This software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.## ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.
Package: qoqo-qasm
qoqo-qasmQasm interface for the qoqo quantum toolkit byHQS Quantum Simulations.qoqo-qasm provides the QasmBackend class that allows users translate a qoqo circuit into a qasm file.
Not all qoqo operations have a corresponding qasm expression.Circuits containing operations without a corresponding expression can not be translated.A source distribution now exists but requires a Rust install with a rust version > 1.47 and a maturin version { >= 0.14, <0.15 } in order to be built.General NotesThis project is partly supported byPlanQK.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.
Package: qoqo-qiskit
qoqo_qiskitQiskit interface for the qoqo quantum toolkit byHQS Quantum Simulations.InstallationWe provide pre-built binaries for linux, macos and windows on x86_64 hardware and macos on arm64. Simply install the pre-built wheels withpipinstallqoqo-qiskitGeneralQiskit is under the Apache-2.0 license ( seehttps://github.com/Qiskit/qiskit/blob/master/LICENSE.txt).qoqo_qiskit itself is also provided under the Apache-2.0 license.TestingThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.If you find unexpected behaviour please open a github issue. You can also run the pytests in qoqo_qiskit/tests/ locally.
Package: qoqo-qiskit-devices
qoqo_qiskit_devicesQiskit devices interface for the qoqo quantum toolkit byHQS Quantum Simulations.In order to make the update a device instance with Qiskit's information possible, the user has to run the following code before using this package:fromqiskit_ibm_providerimportIBMProviderIBMProvider.save_account(token=MY_API_TOKEN)WhereMY_API_TOKENis the API key that can be found in the account settings of the IBM Quantum website after registration.InstallationWe provide pre-built binaries for linux, macos and windows on x86_64 hardware and macos on arm64. Simply install the pre-built wheels withpipinstallqoqo-qiskit-devicesGeneralQiskit is under the Apache-2.0 license ( seehttps://github.com/Qiskit/qiskit/blob/master/LICENSE.txt).qoqo_qiskit_devices itself is also provided under the Apache-2.0 license.TestingThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.If you find unexpected behaviour please open a github issue. You can also run the pytests in qoqo_qiskit_devices/python_tests/ locally.
Package: qoqo-quest
qoqo-questQuESTsimulator backend for the qoqo/roqoqo quantum toolkit byHQS Quantum Simulations.This repository contains three components:The qoqo_quest backend to simulate quantum programms from the qoqo python interface to roqoqo,The roqoqo-quest backend backend to simulate quantum programms from roqoqo directly,The quest-sys crate providing rust bindings for the QuEST C library.qoqo-questQuESTbased simulator backend for the qoqo quantum toolkit byHQS Quantum Simulations.qoqo-quest allows to simulate the execution of qoqo quantum circuits with the help of the QuEST quantum simulator.
Based on QuEST qoqo supports the simulation of error-free and noisy quantum computers.
qoqo-quest is designed to be able to simulate all operations that are part of qoqo.
For usage examples see the examples section ofqoqoInstallationFor linux and macos and windows on x86_64 hardware and macos on arm64 pre-built Python packages are available on PyPi and can be installed withpipinstallqoqo-questFor other platforms please use the source distribution that requires a Rust install with a rust version > 1.47 and a maturin version in order to be built.After installing Rust (for example viarustup)run the followingpipinstallmaturin
pipinstallqoqo-questroqoqo-questQuESTbased simulator backend for the roqoqo quantum toolkit byHQS Quantum Simulations.roqoqo-quest allows to simulate the execution of roqoqo quantum circuits directly from rust code with the help of the QuEST quantum simulator.
roqoqo-quest is designed to be able to simulate all operations that are part of roqoqo.
For usage examples see the examples section ofroqoqo.QuEST build optionsQuEST supports distributed computing and the use of GPU computing.qoqo-questandroqoqo-questare not tested against distributed builds, but have preliminary support forGPUcomputation. ThePyPidistributed versions do not support GPU computation. For the moment GPU support can be enabled for NVIDIA GPUs using either thecudafeature or thecuquantumfeature when compilingqoqo-questwithmaturinorroqoqo-questas a rust library. Thecudafeature uses QuEST's CUDA-based simulator implementation and needs the cuda-compiler (nvcc) available during build. Thecuquantumfeature uses the cuda quantum simulator and requires the cuda-compiler (nvcc) during build as well as the cuquantum libraries.General NotesThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.This project has been partly supported byPlanQKand is partially supported byQSolid.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.
Package: qord
QordPython library for Discord API based around asyncio.Features:Object oriented, user friendly interface with no dirty payloads.Easy to customise and manage.Robust handling of HTTP ratelimits.Supports automatic gateway sharding.Development stageQord is currently under it's initial development (alpha) stage. During this phase, There may be breaking changes and public user-facing API should not be considered stable. There would be no efforts in keeping backward compatibility. While the library currently supports the basic functionalities required to build a bot, many essential features are yet to be implemented and for this reason, Qord isn't yet a library to choose for making full fledged bots.The complete lifetime of 0.x version is considered the development phase. More info about thissemantic versioning specification is hereInstallationQord is installed using Python's traditional package manager, pip.pipinstall-Uqordℹ️ On Windows and Mac, you might need to prefix the above command withpython -mfor it work.Qord requiresPython 3.8 or higher.The dependencies are handled by pip automatically, See complete list of dependencies inhere.UsageTo whet your appetite, Let's get a quickstart with an example of a simple "Ping-Pong" bot.importqordintents=qord.Intents.unprivileged()intents.message_content=Trueclient=qord.Client(intents=intents)@client.event(qord.GatewayEvent.READY)asyncdefon_ready(event):print("Bot is ready.")print(f"Shards:{client.shards_count}")print(f"User:{client.user.proper_name}")print(f"Guilds:{len(client.cache.guilds())}")@client.event(qord.GatewayEvent.MESSAGE_CREATE)asyncdefon_message_create(event):message=event.messageifmessage.author.bot:# Don't respond to bot messages.returnifmessage.content=="!ping":awaitmessage.channel.send("Pong!")client.start("BOT_TOKEN")For a brief explanation of this example, seeit's explanation. More examples in theexamplesdirectory.ContributingQord is under heavy development. You can help us in reaching 100% coverage of Discord API by reporting bugs, suggesting features or even directly contributing to the code base, SeeContribution Guidelines.Documentation•Discord Server•PyPi•GitHub•Issues TrackerCopyright (C) nerdguyahmad and contributors 2022, Under the MIT license.
Package: qorus-remote
OverviewThis package contains two scripts:qorus-remote-commands: allows for command-line access to a remote Qorus servermake-release: allows for releases to be created from local filesRemote Qorus CommandsRequires Qorus 5.0.4+ and Python 3Theqorus-remote-commandsscript allows the user to run Qorus and Qore commands on a remote Qorus server using the
Qorus HTTP server and receive the output of the executed command in real time via the WebSocket protocol.This allows the Qorus client to be used on any system with python 3 and to access Qorus running in a container or in
any other type of deployment as long as the HTTP server is accessible.NOTE: theoloadcommand is mean to be used with local files; local files are copied to the server to a temporary
location, and thenoloadis executed on the server with the deployed files.  At the end of the remoteoloadexecution, the temporary files are deleted,InstallationInstall via pip:pip install qorus-remoteUsageqorus-remote-commands [-h|--help|--usage] <NETRC-FILE> <COMMAND> [<COMMAND-ARGS> ...]Concrete Usage Examplesqorus-remote-commands ~/.netrc-qorus-local qctl psqorus-remote-commands ~/.netrc-qorus-local qctl threads qorus-coreqorus-remote-commands ~/.netrc-qorus-local qrest system/starttime.netrc fileVariableDescriptionMandatorymachineip address of the Qorus server machineYesportport of the Qorus server machineYessecureyesif the Qorus server is onhttps, no otherwiseYesloginQorus usernameYespasswordQorus passwordYestimeoutMaximum time in seconds allowed for each of the curl operationNoverboseMakes the script verboseNonodeleteDoes not delete the upload folder on the serverNoExample .netrc fileFor a Qorus server located onhttps://localhost:8011and using the Qorus useradm(.netrc-qorus-local):machine localhost
port 8011
secure yes
login adm
password adm
timeout 120
verbose noCommandsQorus commandsoloadocmdojviewopropostartostatusostopoviewmake-releaseqctlqrestschema-tooluser-toolQore commandsrestschema-reversesfrestsoaputilsqlutilqdpsaprestAliasesIt's recommended to create aliases for each of the above commands like:Unix/Linux:alias oload='qorus-remote-commands ~/.netrc-qorus-local oload $*'Windows:DOSKEY oload=qorus-remote-commands %USERPROFILE%\Qorus\netrc-qorus-local oload $*etcmake-releaseThemake-releasescript allows the user to make Qorus releases that can be manually or automatically deployed to
Qorus servers.Examplesmake-release -U. mylabel services/*.qsdCreates a user-code release with all service files in the default release-dir/mylabel directory.make-release -U. -lmylabel services/*.qsdCeates only the load script manifest for service files in a release named mylabel.qrf
Package: qoscope
qoscopeQoscope is a fork ofWicoperewritten for PySide 6.3 using QML.
It's a oscilloscope app with GUI that uses Arduino for signal acquisition.
The app was created purely for educational purposes and for electronic enthusiasts.The communication is realized via AVR USART.
The oscilloscope is capable of acquiring up to 100 kSamples/s.
I currently have a double speed asynchronous mod (U2X) set up in the firmware
for my own testing and purposes. So there is a smaller error at the expense of the number of samples.
To turn it off, just delete the U2X setting line in the USART initialization and change 8UL to 16UL
in the baud prescaler.Requirementsqoscoperequires Python >= 3.8, and PyQt6 or PySide6.InstallationInstallqoscopewith pippipinstallqoscopeor install the latest dev version with:pipinstallgit+https://github.com/sokolmarek/qoscope@mainYou also need to upload the included firmware to your Arduino board using the
Arduino IDE (or other software). This is the following filefirmware/firmware.ino.Usage/ExamplesAfter uploading the firmware to the Arduino, its pins are used as follows:Analog Pin 0 (PC0): Input signalDigital Pin 6 (PD6): Trigger signalDigital Pin 7 (PD7): Analog trigger threshold levelWhen using the trigger function it is necessary to have the threshold set on digital
pin 7 and the signal on digital pin 6 otherwise the arduino will be blocked until it
receives the trigger. An example circuit with the threshold set to 3V3 might look like this:AppendixIf anyone wonders about the equation I used for baud prescale (to avoid rounding error)
or wants useful literature for AVR and USART, for exampleAVR articlesare a pretty good source within a few topics.
Package: qosd
qosd - display text over your Xorg screenqosdis a command-line tool and python library can display text over your Linux desktop screen:text is displayed over any window (On-Screen-Display)display simple linetail stdintransparency and text style is configurableInstallpip install qosdUsageusage: qosd [-h] [-i] [-m MAXLINES] [-n SESSION_NAME] [-o OPACITY] [-p {topleft,topright,bottomleft,bottomright,center,centerleft,centerright}] [-P POSITION_OFFSET POSITION_OFFSET] [-s STYLE] [-t TIMEOUT] text [text ...]

qosd - display text over your Xorg screen - v20230529

positional arguments:
  text                  text to display, or '-' for stdin

options:
  -h, --help            show this help message and exit
  -i, --no-input        set window transparent to input
  -m MAXLINES, --maxlines MAXLINES
                        default: 30
  -n SESSION_NAME, --session-name SESSION_NAME
                        start named OSD display session, killing previous OSD with same session name
  -o OPACITY, --opacity OPACITY
                        default: 1.0
  -p {topleft,topright,bottomleft,bottomright,center,centerleft,centerright}, --position {topleft,topright,bottomleft,bottomright,center,centerleft,centerright}
                        text position, default=topleft
  -P POSITION_OFFSET POSITION_OFFSET, --position-offset POSITION_OFFSET POSITION_OFFSET
                        offset in pixels from position, default: 0 0
  -s STYLE, --style STYLE
                        default: 'color:"#FFFFFF";background-color:"#99000000";font-size:11pt;font-weight:bold;'
  -t TIMEOUT, --timeout TIMEOUT
                        display timeout in seconds, default: 3

examples:
$ qosd hello
$ tail -f /var/log/{messages,auth.log} | qosd -
Package: qosic-sdk
An unofficial python sdk for theQosICplatform. This platform provides an api to enable mobile money payments
for businesses in Africa.Free software: MIT licenseDocumentation:https://qosic-sdk.readthedocs.io.FeaturesSimple synchronous client to make your payment requestsCover 100% of Qosic public apiClean and meaningful exceptions100 % test coverageConfigurable timeoutsQuickstartFor those of you in a hurry, here’s a sample code to get you started.pipinstallqosic-sdkfromdotenvimportdotenv_valuesfromqosicimportClient,bjconfig=dotenv_values(".env")moov_client_id=config.get("MOOV_CLIENT_ID")mtn_client_id=config.get("MTN_CLIENT_ID")login=config.get("SERVER_LOGIN")pass=config.get("SERVER_PASSWORD")defmain():phone="229XXXXXXXX"mobile_carriers=[bj.MTN(id=mtn_client_id),bj.MOOV(id=moov_client_id)]client=Client(login=login,password=pass,mobile_carriers=mobile_carriers)result=client.pay(phone=phone,amount=500)print(result)ifresult.success:print(f"Everything went fine")result=client.refund(reference=result.reference,phone=phone)print(result)if__name__=="__main__":main()CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: qotto-auth-client
Qotto Auth ClientThe python packageqotto-auth-clientis a client for the APIqotto-authwhich will soon be open sourced.It allows to manage a scoped permission and authentication system.More information coming soon...QuickstartTheQottoAuthServiceclass allows to interact with aqotto-authGraphQL server.fromqottoauthimport*# Initialize the serviceqotto_auth_service=QottoAuthService(QottoAuthGqlApi(QOTTO_AUTH_URL))# Register this applicationapplication=qotto_auth_service.register_application(name=APPLICATION_NAME,description=APPLICATION_DESCRIPTION,)# Register permissionpermission_1=qotto_auth_service.register_permission(name=PERMISSION_1_NAME,description=PERMISSION_1_DESCRIPTION,application=application,)# Fetch current user or memberdefhandle(request)actor=qotto_auth_service.actor(token=request.COOKIES.get(TOKEN_COOKIE_NAME),secret=request.COOKIES.get(SECRET_COOKIE_NAME),)ifqotto_auth_service.is_authorized(actor=actor,permission=permission_1,):# Do somethingelse:# Do something elseYou can instantiate aQottoAuthServicewith aQottoAuthTestApifor testing purposes. In that case you might want to
extend the test api class if you extended service using direct api calls.
Package: qoyllur-quipu
q2 Python packageTheq2code allows you to use the 2019MOOGversion (in its SILENT mode) to calculate elemental abundances of stars and/or determine their atmospheric parameters using the standard techniques of iron line excitation/ionization equilibrium. It also allows you to calculate other fundamental stellar parameters such as mass and age using isochrones. A tutorial is availablehere.InstallationThe new version ofq2can only be installed via pip. Simply try:pipinstallqoyllur-quipuIf you have installed the old version ofq2, you must delete it from your HOME directory and also remove its PATH from bashrc (.bash_profile for Mac OS). Once you have installedq2, open a Jupyter Notebook Environment (or iPython) and importq2.importq2By importingq2, the latest version ofMOOG(2019) will begin to install. The only thing you need to do is declare the kind of machine you are using, i.g., 'rh64' for 64-bit linux (Linux Mint, Ubuntu, etc), 'rh' for 32-bit linux system and 'maclap' for Mac Os. That's all folks. This process is done only once. Note that theq2package requires Python 3.7 or later.Future releases will be upgraded via:pipinstallqoyllur-quipu--upgradeQuickstartFind spectroscopic parameters of a sample of stars using the Sun as the reference star (strict line-by-line differential analysis):importq2data=q2.Data('stars.csv','lines.csv')sp=q2.specpars.SolvePars(grid='marcs')q2.specpars.solve_all(data,sp,'solution.csv','Sun')Measure elemental abundances of a sample of stars with respect to the solar abundances (line-by-line):species_ids=['CI','OI','BaII']q2.abundances.get_all(data,species_ids,'abundances.csv','Sun')AuthorIvan Ramirez (iramirez@tacomacc.edu)MaintainersJhon Yana GalarzaKayleigh MeneghiniPreferred citationIf you make use of this code, please citeRamirez et al. 2014, A&A, 572, A48. The BibTeX entry for the paper is:@ARTICLE{Ramirez2014,author={{Ram{\'\i}rez}, I. and {Mel{\'e}ndez}, J. and {Bean}, J. and {Asplund}, M. and {Bedell}, M. and {Monroe}, T. and {Casagrande}, L. and {Schirbel}, L. and {Dreizler}, S. and {Teske}, J. and {Tucci Maia}, M. and {Alves-Brito}, A. and {Baumann}, P.},title="{The Solar Twin Planet Search. I. Fundamental parameters of the stellar sample}",journal={\aap},keywords={stars: abundances, stars: fundamental parameters, planetary systems, Astrophysics - Solar and Stellar Astrophysics},year=2014,month=dec,volume={572},eid={A48},pages={A48},doi={10.1051/0004-6361/201424244},archivePrefix={arXiv},eprint={1408.4130},primaryClass={astro-ph.SR},adsurl={https://ui.adsabs.harvard.edu/abs/2014A&A...572A..48R},adsnote={Provided by the SAO/NASA Astrophysics Data System}}
Package: qpage
Free Project For Creating Academic Home pageLast Version : 2.0OverviewDependenciesInstallationUsageCreditsOverviewWe developed QPage on Windows but it also run in Linux and Mac-OSX.
QPage is written in Python3, in order to run it, you will need a python
interpereter.DependenciesDownloadAnd Install Last
Version Of Python ( * or use exe folder and skip this step * )InstallationDownloadQPageJust Unzip It !UsageRun setup (for the first use wait to create folders)You can download samples and run in test mode (Optional)Put your profile picture in image folder (jpg , bmp , tiff , gif , png)Put each page details in a text file with page name in doc folder (* In this step you can use [M] , [S] or [L] at the start and [center] at the end of each line to control font size and alignment )Put your resume file (pdf format) in doc folderPut your font file in font folder (Optional)Put your icon file in image folder (Optional) suggested siteEnter your nameChoose your profile image sizeChoose your text and background colorYou can preview your webpageFinished!!! Now you can go and upload output folder contains directly in your hostCreditsHomepage :LinkPyPI : [Link] (http://pypi.python.org/pypi/qpage)LicensePlease refer to the LICENSE file.
Package: qpagent
[![build status](https://git.elenet.me/waimaiqa/qualityplatform.agent/badges/master/build.svg)](https://git.elenet.me/waimaiqa/qualityplatform.agent/commits/master)# QualityPlatform Agent Tool## The document addresshttp://10.12.56.6:8000/agent.doc/index.html## Design PhilosophyProvides a proxy service, receives the task request from the server, and distributes it to the corresponding worker execution## Key FeaturesAndroid [Monkey][Monkey].iOS Monkey with [Fastmonkey][Fastmonkey].Macaca [UiRecorder][UiRecorder].Compatibility Test.Appcrawler.appstore crawler and xiaomi crawler.## Learn moreYou can read this [blog][Elemeqa-blog] to learn more about the background and initial thoughts ofqpagent.[Monkey]:https://developer.android.com/studio/test/monkey.html[Fastmonkey]:https://github.com/zhangzhao4444/Fastmonkey[UiRecorder]:https://github.com/alibaba/uirecorder[Elemeqa-blog]:https://elemeqa.github.io/
Package: qpageview
qpageviewprovides a page based document viewer widget for Qt5/PyQt5.It has a flexible architecture potentionally supporting many formats.
Currently, it supports SVG documents, images, and, using the Poppler-Qt5
binding, PDF documents.import qpageview

from PyQt5.Qt import *
a = QApplication([])

v = qpageview.View()
v.show()
v.loadPdf("path/to/afile.pdf")Homepage•Development•Download•Documentation•LicenseFeaturesVersatile View widget with many optional mixin classes to cater for
anything between basic or powerful functionalityRendering in a background thread, with smart priority control, so display of
large PDF documents remains fast and smoothAlmost infinite zooming thanks to tile-based rendering and cachingMagnifier glassPrinting functionality, directly to cups or via Qt/QPrinterCan display pages originating from different documents at the same timeCan show the difference between pages that are almost the same via
color compositionAnd much more! And…all classes are extendable and heavily customizable,
so it is easy to inherit and add any functionality you want.DependenciesPython 3.6+Qt5PyQt5python-poppler-qt5 (needed for display of PDF documents)pycups (optionally, needed to print to a local CUPS server)