Saravanan666/pypi-org huggingface dataset:
Package: qlearnkit
Qlearnkit python libraryQlearnkit is a simple python library implementing some fundamental Machine Learning models and algorithms for a gated quantum computer, built on top ofQiskitand, optionally,Pennylane.InstallationWe recommend installingqlearnkitwith pippipinstallqlearnkitNote:pip will install the latest stable qlearnkit.
However, the main branch of qlearnkit is in active development. If you want to test the latest scripts or functions please refer todevelopment notes.Optional InstallVia pip, you can installqlearnkitwith the optional extension
packages dependent onpennylane. To do so, runpipinstallqlearnkit['pennylane']Docker ImageYou can also use qlearnkit via Docker building the image from the providedDockerfiledockerbuild-tqlearnkit-fdocker/Dockerfile.then you can use it like thisdockerrun-it--rm-v$PWD:/tmp-w/tmpqlearnkitpython./script.pyGetting started with QlearnkitNow that Qlearnkit is installed, it's time to begin working with the Machine Learning module.
Let's try an experiment using the QKNN Classifier algorithm to train and test samples from a
data set to see how accurately the test set can be classified.fromqlearnkit.algorithmsimportQKNeighborsClassifierfromqlearnkit.encodingsimportAmplitudeEncodingfromqiskitimportBasicAerfromqiskit.utilsimportQuantumInstance,algorithm_globalsfromqlearnkit.datasetsimportload_irisseed=42algorithm_globals.random_seed=seedtrain_size=32test_size=8n_features=4# all features# Use iris data set for training and test dataX_train,X_test,y_train,y_test=load_iris(train_size,test_size,n_features)quantum_instance=QuantumInstance(BasicAer.get_backend('qasm_simulator'),shots=1024,optimization_level=1,seed_simulator=seed,seed_transpiler=seed)encoding_map=AmplitudeEncoding(n_features=n_features)qknn=QKNeighborsClassifier(n_neighbors=3,quantum_instance=quantum_instance,encoding_map=encoding_map)qknn.fit(X_train,y_train)print(f"Testing accuracy: "f"{qknn.score(X_test,y_test):0.2f}")DocumentationThe documentation is availablehere.Alternatively, you can build and browse it locally as follows:first make sure to havepandocinstalledsudoaptinstallpandocthen runmakedocthen simply opendocs/_build/index.htmlwith your favourite browser, e.g.bravedocs/_build/index.htmlDevelopment notesAfter cloning this repository, create a virtual environmentpython3-mvenv.venvand activate itsource.venv/bin/activatenow you can install the requirementspipinstall-rrequirements-dev.txtnow run the testsmaketestMake sure to runpre-commitinstallto set up the git hook scripts. Nowpre-commitwill run automatically ongit commit!AcknowledgmentsThe Quantum LSTM model is adapted from thisarticlefrom Riccardio Di Sipio, but the Quantum part
has been changed entirely according to the architecture described in thispaper.
Package: qleda
QLEDAQLEDA is a python project to read or create schematics and netlists.
The data model uses the popular frameworkSQLAlchemy.
Therfore the created data can be stored in either aPostgreSQLdatabase or in aSQLitedatabase.Coding RulesIn generalPython Style Guide PEP 8should be respected.SQL Alchemyrelationship:If files are on the same hierarchy (same package) use 'back_populates' wherever possible since it improves code
readability.
If a package/class e.g. 'B' depends on package 'A' but 'A' not on 'B', use 'backref' in order to avoid unnecessary
dependencies.Table namesTable names shall be lowercase of the Class name with an underscore. It's allowed to shorten the name where it makes sense.FileStructurecommon/TBDcore/all basic functionalities are heredrawing/everything related to graphical representationpypads/importer function to read library and schemtic data from PADS Logic ascii files.TestingAdd unittests in a subfolder namedtest. Name every unittest filetest_+file_to_test.
To run all tests run:python-munittestdiscover-t./-sqleda/from the project base directory.SetupAt least Python 3.9 is required.
Installrequirements.txt.
Package: qleet
qLEETis an open-source library for exploringLoss landscape,Expressibility,Entangling capabilityandTraining trajectoriesof noisy parameterized quantum circuits.Key FeaturesWill supportQiskit’s,Cirq’sandpyQuil'squantum circuitsandnoise models.Provides opportunities to improve existing algorithms likeVQE,QAOAby utilizing intuitive insights from the ansatz capability and structure of loss landscape.Facilitate research in designing new hybrid quantum-classical algorithms.InstallationqLEET requires Python version 3.7 and above. Installation of qLEET, as well as all its dependencies, can be done using pip:python -m pip install qleetExamplesProperties of an AnsatzAnsatzExpressibility and Entanglement SpectrumSolving MAX-CUT using QAOAProblem GraphLoss Landscape and Training TrajectoriesContributing to qLEETWe love your input! We want to make contributing to this project as easy and transparent as possible, whether it's:Reporting a bugSubmitting a fixProposing new featuresFeel free to open an issue on this repository or add a pull request to submit your contribution. Adding test cases for any contributions is a requirement for any pull request to be mergedFinancial SupportThis project has been supported byUnitary Fund.LicenseqLEET isfreeandopen source, released under the Apache License, Version 2.0.ReferencesExpressibility and Entangling Capability of Parameterized Quantum Circuits for Hybrid Quantum‐Classical Algorithms, Sim, S., Johnson, P. D., & Aspuru‐Guzik, A. Advanced Quantum Technologies, 2(12), 1900070. Wiley. (2019)Visualizing the Loss Landscape of Neural Nets, Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, Tom Goldstein, NIPS 2018, arXiv:1712.09913 [cs.LG] (2018)
Package: qlever
QLever ControlThis is a very small repository. Its main contents is a scriptqleverthat can control everything that QLever does. The script is supposed to be very
easy to use and pretty much self-explanatory as you use it. If you use docker, you
don't even have to download any QLever code (docker will pull anything it needs)
and the script is all you need.Directory structureWe recommend that you have a directory "qlever" for all things QLever on your machine,
with subdirectories for the different components, in particular: "qlever-control" (this
repository), "qlever-indices" (with a subfolder for each of your datasets), and "qlever-code"
(only needed if you don't want to use docker, but compile the binaries on your machine).QuickstartCreate an empty directory (preferably as a subdirectory of "qlever-indices", go there,
and call theqleverscript once with its full path and a dot and a space preceding it,
and the name of a preconfiguration as only argument. For example:. /path/to/qlever olympicsThis will create aQleverfilepreconfigured for the120 Years of Olympicsdataset, which is
a great dataset to get started because it's small. Other options are:scientists(another small test collection),dblp(larger),wikidata(very large),
and more. If you leave out the argument, you get a defaultQleverfile, which you need
to edit first to use for your own dataset (it should be self-explanatory, after you have
played around with and looked at one of the preconfigured Qleverfiles).Now you can callqleverwithout path and without a dot and a space preceding it and
with one or more actions as argument. To see the set of avaiable actions, just use the
autocompletion. When you are a first-timer, execute these commands one after the other
(without the comments):qlever get-data       # Download the dataset
qlever index          # Build a QLever index for your data
qlever start          # Start a QLever server using that index
qlever example-query  # Launch an example queryEach command will not only execute the respective action, but it will also show you
the exact command line it uses. That way you can learn, on the side, how QLever works
internally. If you just want to know the command used for a particular action, but
not execute it, you can append "show" like this:qlever index showYou can also perform a sequence of actions with a single call, for example:qlever stop remove-index index startThere are many more actions. The script supports autocompletion. Just type "qlever "
and then TAB and you will get a list of all the available actions.
Package: qlibs
Welcome to QLibsQLibs is a multipurpose library, suitable for making graphical applications and games.FeaturesThere are quite a lot of them!Resource system.Math: vectors and matrices.Wavefont OBJ loading and rendering.Window creation and widgets.Text rendering.Network packets and sockets.More to come.DocumentationSeehttps://intquant.github.io/qlibs/Also there are examples.InstallationUsepip install qlibs[full]to install all dependencies.pip install qlibswill install only MIT-licensed dependencies.--no-depsswitch can be used to ignore dependencies, most of library will still work.
Package: qlient
Qlient: Python GraphQL ClientA fast and modern graphql client designed with simplicity in mind.Key FeaturesCompatible with Python 3.7 and aboveBuild on top ofqlient-core,requestsandwebsocket-clientsupport for subscriptionsHelpSeedocumentationfor more details.If you want more information about the internals,
I kindly refer you to theqlient-core documentation.If you are looking for an asynchronous implementation,
I kindly refer you to theqlient-aiohttpsister project.InstallationpipinstallqlientQuick Startfromqlient.httpimportHTTPClient,GraphQLResponseclient=HTTPClient("https://swapi-graphql.netlify.app/.netlify/functions/index")res:GraphQLResponse=client.query.film(# swapi graphql input fieldsid="ZmlsbXM6MQ==",# qlient specific_fields=["id","title","episodeID"])print(res.request.query)# query film($id: ID) { film(id: $id) { id title episodeID } }print(res.request.variables)# {'id': 'ZmlsbXM6MQ=='}print(res.data)# {'film': {'id': 'ZmlsbXM6MQ==', 'title': 'A New Hope', 'episodeID': 4}}
Package: qlient-aiohttp
Qlient AIOHTTP: Python GraphQL ClientA blazingly fast and modern graphql client based on qlient-core and aiohttpKey FeaturesCompatible with Python 3.7 and aboveBuild on top ofqlient-coreandaiohttpsupport for subscriptionsHelpSee thedocumentationfor more details.Quick PreviewThis preview is using the officialgithub/graphql/swapi-graphqlgraphql api.importasynciofromqlient.aiohttpimportAIOHTTPClient,GraphQLResponseasyncdefmain():asyncwithAIOHTTPClient("https://swapi-graphql.netlify.app/.netlify/functions/index")asclient:result:GraphQLResponse=awaitclient.query.film(["title","id"],# fields selectionid="ZmlsbXM6MQ=="# query arguments)print(result.request.query)print(result.data)asyncio.run(main())Which results in the following query being sent to the serverqueryfilm($id:ID){film(id:$id){titleid}}And returns the body below{"film":{"title":"A New Hope","id":"ZmlsbXM6MQ=="}}
Package: qlient-core
Qlient Core: Python GraphQL Client Core LibraryThis is the core for a blazingly fast and modern graphql client that was designed with simplicity in mind.HelpSee thedocumentationfor more details.Quick Previewfromqlient.coreimportClient,Backend,GraphQLResponseclassMyBackend(Backend):"""Must be implemented by you"""client=Client(MyBackend())res:GraphQLResponse=client.query.get_my_thing("name")print(res.request.query)# "query get_my_thing { get_my_thing { name } }"
Package: qlikconnect
qlikconnectqlikconnect is the python library used to interact with Qliksense.It uses qlik engine API to connect with Qliksense through webocket. This module can be use to do things like fetch qlik charts data, evaluate your expression through this and many more.InstallationInstallation is pretty straightforward usingpip:pip install qlikconnectExampleAfter installing the library, importSenseConnectclass as below:ForLocalhost Qliksense Desktop :from qlikconnect import SenseConnect
sc = SenseConnect()For **Enterprise **, certificate details will be required:from qlikconnect import SenseConnect
sc = SenseConnect(domain ='domain_name',
				port='port_number',
				userdirectory='userdirectory',
				userid='userid',
				certPath='folder/path/of/certificates')Certificates also required named 'root.pem', 'client.pem' and 'client_key.pem' which can be exported from qmc.Also you can get the port(4747 by default), userdirectory and userid from qmc.Use CaseTo get the app details :sc.get_list_of_apps(appID)To get last refreshed timestamp of an app :sc.get_last_updated_status(appname)To evaluate an expression from an app :sc.evaluate_expression(appname, expression,e_o_d=0)To export the data from charts to excel :sc.export_data(appname, chartname)Requirement> websocket_client
> python 3 (3.6 recommended)
Package: qlikflow
qlikflowThis module allows you to create simple Apache Airflow DAG files-constructors for QlikView, Qlik Sense and NPrinting.Information filesChangelog :https://github.com/bintocher/qlikflow/blob/main/CHANGELOG.mdManual(en) :https://github.com/bintocher/qlikflow/blob/main/doc/readme.mdThis readme :https://github.com/bintocher/qlikflow/blob/main/README.mdInstallpip3installqlikflowUpgradepip3installqlikflow-UCreate config-fileOpenconfig_generator.pywith your IDE editor, and set settings, save scriptThen run script to createconfig.jsonfilePut thisconfig.jsonfile on your Apache Airflow server in folder:AIRFLOW_HOME/config/Use in DAG-filesfromairflowimportDAGfromairflow.utils.datesimportdays_agofromqlikflowimportqlikflowfromdatetimeimportdatetimetasksDict={u'qliksense. Test task':{'Soft':'qs1','TaskId':'c5d80e71-f574-4655-8874-3a6e2aed6218','RandomStartDelay':10,},u'np100. run nprinting tasks':{'Soft':'np100','TaskId':['taskid1','taskid2','taskid3','taskid4',],'Dep':{u'qliksense. Test task',}}}default_args={'owner':'test','depends_on_past':False,}dag=DAG(dag_id='_my_test_dag',default_args=default_args,start_date=days_ago(1),schedule_interval='@daily',description='Default test dag',tags=['qliksense','testing'],catchup=False)airflowTasksDict={}qlikflow.create_tasks(tasksDict,airflowTasksDict,dag)This code convert into DAG like this:
Package: qlik_sense
Qlik SenseThis library is a python client for the Qlik Sense APIsOverviewThis library allows users to more easily work with Qlik Sense applications in a larger python workflow. While Qlik's
APIs could be used directly, this streamlines the process.Disclaimer:This library, and its maintainer, have no affiliation with QlikTech. Qlik support agreement does not cover
support for this application.RequirementsPython 3.7+requestsrequests_ntlmrequests_negotiate_sspiurllib3uuidmarshmallowInstallationThis package is hosted on PyPI:pipinstallqlik_senseExamplesUse this library to work with Qlik Sense apps:fromqlik_senseimportNTLMClientqs=NTLMClient(host='url/to/qlik/sense/server')app=qs.app.get_by_name_and_stream(app_name='My App',stream_name='My Stream')qs.app.reload(app=app)Full DocumentationFor the full documentation, please visit:https://qlik_sense.readthedocs.io/en/latest/
Package: qlink-interface
QLink-Interface (1.0.0)Welcome to QLink-Interface's README.To install the package do:makeinstallTo verify the installation do:make verifyThis package defines the service interface of the link layer and provides a magic link layer protocol.
For details about this interface and specific header fields see the paper:A Link Layer Protocol for Quantum Networkshttps://arxiv.org/abs/1903.09778and the QIRG draft:The Link Layer service in a Quantum Internethttps://datatracker.ietf.org/doc/draft-dahlberg-ll-quantum
Package: qlite
QLiteDescriptionQLite is a lite project of SQLite ORM at Python3, as lite ORM for lite SQL.Capabilitycreate/drop tables by its QLite ORM-classes;insert/update/delete data by its QLite ORM-objects;select data by QLite query constuctor;select data with autojoin data by foreign key (different strategies);get QLite ORM-object by ID with all its recursion data or one-step data with lazy=TRUE;LinksGitHub -https://github.com/BorisPlus/otus_webpython_005AuthorBorisPlusCommentHomework project аt course “Web-developer by Python” (https://otus.ru/learning)
Package: qlligraphy
Qlligraphy. GraphQL Schema -> Pydantic modelsQlligraphy is a simple CLI tool, that generates pydantic models based on graphQL schema.InstallationpipinstallqlligraphyUsage:Consider the following schema written inexample.gqlenumEpisode{NEWHOPEEMPIREJEDI}typeCharacter{name:String!appearsIn:[Episode]!}Running:qlligraphyexample.gql-oexample.pyResults in the following python file:fromenumimportEnumfromtypingimportList,OptionalfrompydanticimportBaseModelclassEpisode(str,Enum):NEWHOPE="NEWHOPE"EMPIRE="EMPIRE"JEDI="JEDI"classCharacter(BaseModel):name:strappearsIn:List[Optional[Episode]]Please note: This package is still in WIP state.
Package: qlm
A command line app for taking beautiful notes.qlmgives you access to beautiful notes on any machine.The name comes from the Arabic word for pen:قلمwhich makes use of the three letter rootq-l-mto cut, snip, prune, clip or truncate. So
try to keep those notes concise ;-)Basic Usagepip install qlm
qlm connect 'username/repo'
echo '# My notes' > my_note.md
qlm add my_note.md
qlm show my_note.md
Package: qlmaas
Module qlmaasThis moduleqlmaasis the client ofQaptiva Access(a.k.a.QLM as a Service). This module is part ofmyQLMand is used to submit
Quantum jobs to a Qaptiva appliance.PrerequisitesThis version of myQLM works on both Windows, macOS and Linux for different versions of Python 3. Please look at thecompatibility matrixto ensure myQLM is installable on your computer.This module can be installed by typing the following command:pip install myqlmLicensemyQLM EULA
Package: qload
qload : better assertion on filesqload is a library to load or extract content of a file to perform assertion in automatic tests without
boilerplate. It support file from filesystem, ftp, s3, ...Benefitsoneliner to assert on the content of a fileuseful differential when the test fails thanks to subpart extractionsupport for the most common formats (yaml, csv, json, txt)support for multiple file systems and protocols (local, ftp, s3)rich expression engine to extract part of a file (regexpfortextandjmespathforcsv,jsonandyamlto improve differential)Gettings startedpipinstallqloadUsageimportqloadassert'database_url: postgresql://127.0.0.1:5432/postgres'inqload.text('file.txt')assertqload.text('file.txt',expression='Hello .*')=='Hello Fabien'assertqload.json('file.json')=={}assertqload.json('s3://mybucket/file1.json')=={}assertqload.json('file.json',expression='$.id')==''assertlen(qload.json('file.json',expression='$.id'))==4assertqload.yaml('file.yml')=={}assertqload.yaml('file.yml',expression='$.id')==''assertqload.csv('file.csv',expression='[*].Account')==['ALK','BTL','CKL']assertqload.csv('file.csv',expression='[*].Account')[0]=='ALK'assertqload.parquet('file.parquet',expression='[*].Account')[0]=='ALK'assertqload.ftp(host='localhost',port=21,login='admin',password='admin').csv(path='dir/file.csv',expression='')==[]assertqload.s3(bucket='bucket',aws_access_key_id='',aws_secret_access_key='',region_name='eu-west-1',endpoint_url='http://localhost:9090').json(path='dir/file.csv')=={}assertqload.isfile('file.json')isTrueassertqload.s3(bucket='bucket').isfile('file.json')isTrue
Package: qloud-wsgi
Qloud Integration for WSGI Serversqloud-wsgiis a WSGI middleware compatible with all frameworks that support WSGI, likeFlask. It provides a simple way to integrate withQloud.Installationpipinstallqloud-wsgiNote, we currently only support Python 3.7 and above.UsageFlaskfromflaskimportFlask,requestimportqloudSECRET="YOUR_SECRET"app=Flask(__name__)app.wsgi_app=qloud.QloudAuthentication(app.wsgi_app,SECRET,credentials_required=False)@app.route("/")defhello_user():returnrequest.environ.get("auth")or"Hello Anonymous!"TheSECRETis the secret key that you can find in theQloud Console Dashboard,
respectively, for theDevAuth environmentit's fixed
to00000000000000000000000000000000.The middleware injects the decoded JSON Web Token using the keyauthinto the environment of the request (e.g.environ["auth"]in plain WSGI, orrequest.environ.get("auth")in a Flask app).Our documentationhas all the information of the fields present in the
JWT.Credentials RequiredThecredentials_requiredparameter is optional and defaults toFalse. For requests without a JSON Web Token,environ["auth"]will not be set.If your application usesmandatory authentication, we
recommend to setcredentials_requiredtoTrue, the integration itself will then also reject unauthenticated requests
if they bypass the Proxy.
Package: qlsc
The quadrilateralized spherical cube (QLSC) is a geospatial indexing scheme for segmenting a sphere into pixels with the aim of optimized spatial indexing and queries. QLSC is an implementation of this scheme in a Python package. Parts of it are based on code from Sergey Koposov’s Q3C, a PostgreSQL extension that implements QLSC indexing. In addition to sphere segmentation, this package provides the catalog indexing functionality of Q3C without the need to install a PostgreSQL database.This package also enables fast local cone searches on astronomical catalogs without the need to install any other dependencies, supporting essentially unlimited numbers of coordinates (i.e. if you’re familiar with Q3C, the same can be performed without PostgreSQL).
Package: qlty
qltyUnstitch and stich back pytorch tensorsFree software: BSD licenseDocumentation:https://qlty.readthedocs.io.FeaturesCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-10-20)First release on PyPI.0.1.1 (some time ago)Minor bug fixes0.1.2. (2022-9-13)Support for N-channel 3D tensorsOn disc-accmulation for large datasets0.1.3. (2022-9-13)Cleanup and ready to redistribute0.1.4. (2023-8-28)Bug fix / behavoir change
Package: qlua
Qlua (Quik LUA RPC Python)PythonAPI
для торгового терминалаQuik.
Представляет собой клиентскую часть дляQuik LUA RPC.Принцип работыТерминалQuikпредоставляет API для языка программирования LUA.ПроектQuik LUA RPCпозволяет обращаться к Quik LUA API, через сетевое подключение.ZeroMQобеспечивает передачу данных по сети и аутентификацию.Protocol Buffersпозволяет программам, написанным на разных языках программирования, быстро обмениваться данными.Проект Qlua, описание которого вы читаете, позволяет взаимодействовать с Quik LUA RPC из языка программирования Python.Таким образом ваш код на Python взаимодействует с API Quik.УстановкаУстановите пакетqlua:pipinstallqluaМожно пользоваться API.Примеры использованияqlua/examplesИнтерфейс командной строки можно вызвать используя:python-mqlua-hВнимание!Для работы CLI (интерфейса командной строки) требуется:python >= 3.7.0Дляpython < 3.8.0необходимо установитьMyPy:pipinstallmypyДокументацияБолее подробная документация находится вWiki.
Package: qm
Quine-McCluskey two-level logic minimization method.Copyright 2008, Robert Dick <dickrp@eecs.umich.edu> with improvements
from Pat Maupin <pmaupin@gmail.com>.Routines to compute the optimal sum of products implementation from sets of
don’t-care terms, minterms, and maxterms.Command-line usage example:qm.py -o1,2,5 -d0,7Library usage example:import qm
print qm.qm(ones=[1, 2, 5], dc=[0, 7])Please see the license file for legal information.
Package: qmarkpg
The qmarkpg package is apsycopg2wrapper allowing the use of “qmark”
placeholders style for query arguments (i.e.?instead of%s).
There is no support for parameters dictionaries: only positional parameters
are allowed.Adopting “qmark” and dropping support for “format” (i.e.%s) and
“pyformat” (i.e.%(name)s) placeholders is not in program for future
Psycopg versions; however, maintainers of multi-database environments may find
the “qmark” placeholder style more useful for cross-database compatibility:
this module is designed to support such requirement without requiring
extensive rewriting of application directly using psycopg2.
Package: qmasm
QMASM fills a gap in the software ecosystem forD-Wave's adiabatic quantum computersby shielding the programmer from having to know system-specific hardware details while still enabling programs to be expressed at a fairly low level of abstraction.  It is therefore analogous to a conventional macro assembler and can be used in much the same way: as a target either for programmers who want a great deal of control over the hardware or for compilers that implement higher-level languages.