Saravanan666/pypi-org huggingface dataset:
Package: qmodels
Simulation of Queuing Models with SimulusJason Liu, July 2019.This is a tutorial describing how to usesimulusto model queuing systems. Simulus is an open-source discrete-event simulator in Python. The tutorial consists of several Jupyter notebooks, on which we develop and run simulation code. The tutorial also comes with a python module containing all example code.How to Follow this TutorialYou have three options:Launch a live notebook server with these notebooks usingBinder, which provides an executable environment for running Jupyter notebooks. Access the binder at the following URL:https://mybinder.org/v2/gh/liuxfiu/qmodels.git/master?filepath=notebooks%2Fintro.ipynbRun the notebooks on your own machine. The notebooks are available in the github repository (https://github.com/liuxfiu/qmodels.git) under the 'notebooks' directory. To run the notebooks, you need to first have the following packages installed:jupyter: a web application for sharing interactive documents that contain text, code, and data visualizationnumpy: a library for efficient representation of multi-dimensional arraysscipy: a library for numerical computations, including linear algebra and statisticsmatplotlib: a 2-D plotting librarysimulus: the discrete-event simulator for which we developed this tutorialYou can install all these packages including the examples of this tutorial using thepipcommand, such as the following:python -m pip install --user qmodelsRead the documents online:http://qmodels.readthedocs.io/. However, you won't be able to run the code within the notebooks with this option.
Package: qmp
QEMU Machine Protocol clientQMPQEMU Machine Protocol (QMP) is a JSON-based protocol that allows applications to
communicate with a QEMU instance.For a brief introduction to QMP, seehttps://wiki.qemu.org/Documentation/QMP.For detailed information about the protocol, seeQEMU Machine Protocol Specification — QEMU documentation.For the full list of commands supported by QMP seeQEMU QMP Reference Manual — QEMU documentation.About the projectThis PyPI project packages a single fileqmp.pyfrom the QEMU source tree:https://github.com/qemu/qemu/blob/v5.0.0/python/qemu/qmp.py.This PyPI project was created in 2019.A different project offering a solution to the same problem (and more) has been
created in 2021:https://pypi.org/project/qemu.qmp/. You may want to use it.
Package: qmpy
[ ![Build Status](https://api.travis-ci.org/wolverton-research-group/qmpy.svg?branch=master) ](https://travis-ci.org/wolverton-research-group/qmpy)
[ ![PyPI version](https://badge.fury.io/py/qmpy.svg) ](https://badge.fury.io/py/qmpy)A toolkit for storing crystal structure data, automating density-functional
calculations, handling computational resources and performing thermodynamic
analysis. qmpy is used to run and maintain the Open Quantum Materials Database
([oqmd.org](http://www.oqmd.org)).Install qmpy with pip:pip install qmpyFor more complete documentation, see:http://oqmd.org/static/docs/index.html
Package: qmpy-rester
qmpy_resterA python wrapper for OQMD API (PyPI). This code is written in python 3.Installationpip install qmpy_resterUsage1. Get data through omqd-api1.1 Exampleimportqmpy_resterasqr## Return list of datawithqr.QMPYRester()asq:kwargs={‘element_set’:‘(Fe-Mn),O’,# composition include (Fe OR Mn) AND O‘stability’:‘<-0.1’,# hull distance smaller than -0.1 eV‘natom’:‘<10’,# number of atoms less than 10}list_of_data=q.get_oqmd_phases(**kwargs)## Return data of a single oqmd phasewithqr.QMPYRester()asq:phase=q.get_oqmd_phase_by_id(fe_id=4061139,fields='!sites')# Default: fields=None1.2 Allowed attributescomposition: compostion of the materials or phase space, e.g. Al2O3, Fe-Oelement_set: the set of elements that the compound must have, '-' for OR, ',' for AND, e.g. (Fe-Mn),Oicsd: whether the structure exists in ICSD, e.g. False, True, F, Tprototype: structure prototype of that compound, e.g. Cu, CsClgeneric: chemical formula abstract, e.g. AB, AB2spacegroup: the space group of the structure, e.g. Fm-3mnatoms: number of atoms in the supercell, e.g. 2, >5volume: volume of the supercell, e.g. >10ntypes: number of elements types in the compound, e.g. 2, <3stability: hull distance of the compound, e.g. 0, <-0.1,delta_e: formation energy of that compound, e.g. <-0.5,band_gap: band gap of the materials, e.g. 0, >2fields: return subset of fields, e.g. 'name,id,delta_e', '!sites'filter: customized filters, e.g. 'element_set=O AND ( stability<-0.1 OR delta_e<-0.5 )'limit: number of data return at onceoffset: the offset of data return2. Get data through optimade api format2.1 Exampleimportqmpy_resterasqr## Return list of datawithqr.QMPYRester()asq:kwargs={‘elements’:‘Fe,Mn’,# include element Fe and Mn‘nelements’:‘<5’,# less than 4 element species in the compound‘_oqmd_stability’:‘<0’,# stability calculted by oqmd is less than 0}list_of_data=q.get_optimade_structures(**kwargs)## Return data of a single structurewithqr.QMPYRester()asq:structure=q.get_optimade_structure_by_id(id=4061139,fields='!_oqmd_sites')# Default: fields=None1.2 Allowed attributeselements: the set of elements that the compound must have, e.g. Si,Onelements: number of elements types in the compound, e.g. 2, <3chemical_formula: compostion of the materials, e.g. Al2O3formula_prototype: chemical formula abstract, e.g. AB, AB2_oqmd_natoms: number of atoms in the supercell, e.g. 2, >5_oqmd_volume: volume of the supercell, e.g. >10_oqmd_spacegroup: the space group of the structure, e.g. Fm-3m_oqmd_prototype: structure prototype of that compound, e.g. Cu, CsCl_oqmd_stability: hull distance of the compound, e.g. 0, <-0.1,_oqmd_delta_e: formation energy of that compound, e.g. <-0.5,_oqmd_band_gap: band gap of the materials, e.g. 0, >2fields: return subset of fields, e.g. 'elements,chemical_formula', '!_oqmd_sites'filter: customized filters, e.g. 'elements=O AND ( _oqmd_stability<-0.1 OR _oqmd_delta_e<-0.5 )'limit: number of data return at onceoffset: the offset of data return
Package: qm-qua
QM-QUA SDKQUA is a pulse-level language used to control a Quantum System.
Read more about it and it's uses here:https://arxiv.org/abs/2303.03816This package, QM-QUA, is an implementation that uses the Quantum Machines QOP controller and is used both to
communicate with the QOP and to implement a Pythonic implementation (DSL) of QUA.To learn how to use this package, please visit the documentation website at:https://qm-docs.qualang.io/
Package: qm-sim
QM_simPython library for simulation of quantum mechanical systems. The documentation is available onGitHub pages.Features1D, 2D, and 3D systemsChoice of finite difference schemeZero and periodic boundary conditionsStationary and temporal solutionsPlotsPlanned featuresTransfer matrix for transmission ect.Proper testingInstallationpip install qm-simTo be able to use thePyTorchbackend for eigenvalue calculations, run the following command:pip install qm-sim[torch]This will install the cpu-version of the package. To run GPU calculations, install the version for your system at thePyTorch websiteinstead.UsageExamples are provided in theexamples/-folder.
These are enumerated with increasing level of simulation complexity.ContributionTo contribute, please open a pull request to thedev-branch onGitHub.LintingWhen opening a PR, a linting check is performed.
To ensure your contribution passes the checks, you can run the following$pipinstall.[linting]$blacksrc/qm_sim
$isortsrc-m3--trailing-comma
$pylintsrc--fail-under=7SetupThe following is an example of how to set up VS Code for development, adapt to your IDE of choice.TL;DR:pip install -e .to install in an editable stateRequirementsVS CodePython extensionPython 3.10 or aboveStepsClone the repo recursively and open the repo in VS Code. If not cloned recursively, initialize the submodules withgit submodule update --initPress f1, and runPython: Create Environment. Select.venvOpen a new terminal, which should automatically use the virtual environment. If not, run.venv\Scripts\activateon Windows, orsource .venv/bin/activateon UnixIn the same terminal, runpip install -e .[test]to install the current directory in an editable state, and the testing utility PytestTo run tests, press f1 and runPython: Configure Tests. Choosepytest. Run tests in the testing menu
Package: qmsolve
QMsolve: A module for solving and visualizing the Schrödinger equationQMsolve seeks to provide easy solid and easy to use solver, capable of solving the Schrödinger equation for one and two particles,
and creating descriptive and stunning visualizations of its solutions both in 1D, 2D, and 3D.Installationpip install qmsolveHow it worksThe way this simulator works is by discretizing and Hamiltonian of an arbitrary potential,
specified as a function of the particle observables. This is achieved with theHamiltonianconstructor.
Then, theHamiltonian.solvemethod efficiently diagonalizes the Hamiltonian and outputs the energies and the eigenstates of the system.
Finally, the eigenstates can be plotted with thevisualizationclass.Thevisualization.superpositionsmethod features the possibility of interactively visualizing a superposition of the computed eigenstates and studying
the time dependence of the resulting wavefunction.For efficiently solving the time dependent Schrödinger equation,TimeSimulationclass must be used. It takes as an argument the Hamiltonian you have previously defined, and the method you desire to use.For a quick start, take a look to the examples found in the examples subdirectory.
Package: qmss-sl-practice
qmss-sl-practiceThis is a practice package.Installation$pipinstall-ihttps://test.pypi.org/simple/qmss_sl_practiceFeaturesTODODependenciesTODOUsageTODODocumentationThe official documentation is hosted on Read the Docs:https://qmss_sl_practice.readthedocs.io/en/latest/ContributorsWe welcome and recognize all contributions. You can see a list of current contributors in thecontributors tab.CreditsThis package was created with Cookiecutter and the UBC-MDS/cookiecutter-ubc-mds project template, modified from thepyOpenSci/cookiecutter-pyopensciproject template and theaudreyr/cookiecutter-pypackage.
Package: qmt
Theqmttoolbox (Quaternion-based Inertial Motion Tracking Toolbox) is a collection of functions, algorithms,
visualization tools, and other utilities with a focus on IMU-based motion tracking. Thesource codeis hosted on GitHub.DocumentationDetailed documentation can be found online athttps://qmt.readthedocs.io/.InstallationThe qmt Python package can easily be installed fromPyPIvia pip, e.g.:pipinstallqmtTo run webapps, install eitherPySide6orPySide2. If neither PySide6 nor PySide2 work on your system, webapps can still be
displayed with a Chromium browser window fallback.To install the toolbox from source, run:./build_webapp_lib.shpipinstall--user-e".[dev]"./build_docs.shFor more information, please refer to thedocumentation.LicenseThe qmt toolbox is licensed under the terms of theMIT license.SPDXheaders and theREUSEspecification are used
to track authors and licenses of all files in this repository.This repository also contains code, typically released together with scientific publications, for which the original
authors did not provide any licensing information. We distribute this code under the assumption that authors who
publish code for the scientific community intend for the code to be used for scientific research. All such files are
marked with the SPDX license identifier LicenseRef-Unspecified and the origin of the code is documented in the
respective files or directories.ContactDaniel Laidig <laidig at control.tu-berlin.de>
Package: qmtools
QMToolsQuantum Mechanics Tools for Python.GoalMotivated by the work and computational activities of the Quantum Physics Fundamentals course, I decided, even as a personal challenge, to create a didactic package for the study of this course. Therefore, the material was thought to leave everything well documented and straight to the point. In this way, the library has basic functions for those who want to go quick and dirty, but also allow the most curious to explore the possibilities.RequirementsPython: >=3.9 (should work in >=3.6, but still need some tests)Libraries: NumPy, Scipy, Plotly (optional)InstallationTheqmtoolspackage is hosted on PyPi. Thus, it is possible to install this library in  virtual environment usingpip(use the appropriate command for your system):~ pip install qmtools
~ pip3 install qmtools
~ python -m pip install qmtools
~ python3 -m pip install qmtoolsLicenceThe licence for this project is GPLv3 which means, in short, that the code is open source and those who are going to use it must leave their projects open source as well.
Package: qmusic
Qmusic API WrapperRequirementsPython 3.6+InstallationInstall with pippip install qmusicDescriptionAn unofficial Python Qmusic API Wrapper. You can find the documentationhere.
It will keep working until Qmusic changes their api. In that case I will update it as soon as possible.If you have any further questions you can contact me on Discord: svenskithesource#2815ChangelogSeeCHANGELOG.mdLicenseSeeLICENSE
Package: qmxgraph
QmxGraphThis a Qt widget that embeds a rich and powerful graph drawing tool
using JavaScript’s mxGraph library.It makes use of Qt web view features to make this possible. Since
current Qt version supported (<= 5.6) is still usingWebKitas its web
browser engine, all of its limitations apply when developing new embedded web
features.History0.1.0 (2017-01-03)First version.
Package: qna-builder
QnA BuilderIntroductionQnA Builderis a simple, no-code way to build chatbots in Python. It provides a similarity-based conversational dialog
engine,QnA Bot, which makes it easy to generate automated responses to input questions according to a set of known
conversations, i.e., question-answer pairs, stored in aknowledge base. QnA Bot relies on a collection of
question-answer pairs to generate answers for new inputs.InstallThe easiest way to install the qna-builder is by usingpip:pipinstallqna-builderThis library is shipped as an all-in-one module implementation with minimalistic dependencies and requirements.Getting startedA QnA Bot can be set up and used in four simple steps:ImportQnABotclassfromqnabuilderimportQnABotInitialize a botbot=QnABot()Fit the bot engine to a knowledge basebot.fit(kb="knowledge_base.json")Generate answersbot.answer("Hey. What's up?")"All good. What's up with you?"AlgorithmsCurrently, QnA Bot engine supports the following algorithms for similarity-based answer generation:TF-IDF Vectorization ('tfidf')Murmurhash3 Vectorization ('murmurhash')Count Vectorization ('count')Supported similarity metrics are as follows:Cosine similarity ('cosine')Euclidean distance ('euclidean')Manhattan distance ('manhattan')Knowledge base editorBy callingrun_editor()method ofQnAKnowledgeBaseclass, the knowledge base editor window will open up in
your web browser and allows you to edit your knowledge base by adding, removing, or modifying questions/answers.fromqnabuilderimportQnAKnowledgeBasekb=QnAKnowledgeBase('my_knowledge_base.json')kb.run_editor()Here, you can see a screenshot of the knowledge base editor:Note that you need to install the optional requirementstreamlitto be able to use the
knowledge base editor.TestsTo run the tests, install development requirements:pip install -r requirements_dev.txtThen, run pytest:pytest
Package: qnap-qsw
python-qnap-qsw is a Python module implementing an interface to the QNAP QSW API.
It allows a user to gather all the information from a QNAP switch.This package has been developed to be used withhttps://home-assistant.io/but it can be used in other contexts.Disclaimerpython-qnap-qsw was created for my own use, and for others who may wish to experiment with personal Internet of Things systems.I have no connection with QNAP. I receive no help (financial or otherwise) from QNAP, and have no business interest with them.This software is provided without warranty, according to the GNU Public Licence version 2, and should therefore not be used where it may endanger life, financial stakes, or cause discomfort and inconvenience to others.Usage>>> from qnap_qsw.interface import QSA
_qsa = QSA(host="host/url")
_qsa.login(user="admin", password="password")
_qsa.get_system_board()
_qsa.get_system_sensor()
_qsa.logout()
Package: qnapstats
Library from obtaining system information from QNAP NAS devices.InstallationThis library requiresxmltodict, so make sure you have that installed:pip3installxmltodict>=0.10.0Then install this Python module:pip3installqnapstatsUsage Example#!/usr/bin/env python3fromqnapstatsimportQNAPStatsfrompprintimportpprintqnap=QNAPStats('192.168.1.3',8080,'admin','correcthorsebatterystaple')pprint(qnap.get_system_stats())pprint(qnap.get_system_health())pprint(qnap.get_smart_disk_health())pprint(qnap.get_volumes())pprint(qnap.get_bandwidth())Note:The user you connect with must be in the admin group.Device SupportThis library has been tested against the following devices and firmwares:ModelQTS Firmware VersionsNotesD4 Pro4.5.1User-reported: no automated testsTS-1104.2.4TS-2104.2.6This device does not report CPU tempsTS-219P II4.3.3User-reported: no automated testsTS-251B4.4.3TS-251+4.5.1No information on dnsInfoTS-253 Pro4.5.2TS-253D4.5.3TS-269L4.3.3User-reported: no automated testsTS-4104.2.3This device does not report CPU tempsTS-4124.3.3This device does not report CPU tempsTS-431P4.3.4TS-4514.2.2 - 4.2.4TS-453A4.3.4TS-453Be4.2.3TS-6394.2.3TS-6594.2.6May reportNonefor some disk tempsTS-1677XU-RP4.5.2TS-EC1280U4.5.2TS-X534.5.4Other QNAP devices using these firmwares should probably work fine, as should the devices listed above on newer firmwares.
If you encounter any compatibility issues, please let us know (or better yet, contribute a patch!)
Package: qnas
Welcome to QnAS - an open source
program to simulate noisy quantum algorithms!Installation guide: Go to PyPI and find QnAS,
there you can find the installation command!
Or you can find it here:pip install qnasMIT License: Free to use!To see source code, go to:https://github.com/isakwi/Kandidatarbete/tree/main/qnasTo get started with QnAS, import QnAS to your
program and call the help function:import qnas

qnas.help()To get even more help, here comes an example
of how you can use qnas.solve() to solve
a very simple system of 3 qubits given that you
have a qubit parameter file called
'qubitData.csv':import qnas
import qiskit
from numpy import pi

circuit = qiskit.QuantumCircuit(3)
circuit.rx(pi,0)
circuit.rx(pi,1)
circuit.rx(pi,2)

finalStates = qnas.solve(Qbfile='qubitData.csv', circuit=circuit)Here's an example of how the 'qubitdata.csv' should look like:Qubit;Relaxation(MHz);Dephasing(MHz);Thermal(MHz);Anharmonicity(MHz);Levels
01;1.1;1.2;0.00;-229;3
02;1.3;1.0;0.00;-225;3
03;1.2;1.4;0.00;-226;3To add more qubits, just add more rows to the csv file!
Package: qnc-crud
qnc_crudWORK IN PROGRESSA rather opinionated framework to help create multi-page CRUD/form-heavy web apps. Comes with a collection of django and js utilities which can also be used in a more flexible way, without opting-in to the entire framework.Intended to be installed as an "app" in a django project, but also useful in other web projects just for the js files.No Full-Page Form SubmissionsYou should never use standard form submission (which loads a new page). Meaningless entries end up in browser history, page state is lost, file inputs are cleared if there are form errors. The list of issues is long.ajax_all_forms.js automatically makes all of your forms submit via ajax, and executes the code returned by your server.set_form_errors.js provides useful helper utilities for generating form error messages.Automatic Page Invalidationreload_if_necessary.js will cause pages to reload automatically, if any form has been POSTED by the user (same browsing session) at some time after the page was initially renderedThis means the user can navigate back in history (after logging in/out, manipulating data, etc.), and the page will reload.
Also, the user can make changes in one window, and those changes will be reflected in another window as soon as the user focuses that window.Form Pages Removed From HistoryEdit Forms Go BackAdd Forms Replace LocationAutomatic Back Button
Package: qndiag
Quasi-Newton algorithm for joint-diagonalizationSummaryThis Python package contains code for fast joint-diagonalization of a set of
positive definite symmetric matrices. The main function isqndiag,
which takes as input a set of matrices of size(p, p), stored as a(n, p, p)array,C. It outputs a(p, p)array,B, such that the matricesB @ C[i] @ B.T(python), i.e.B * C(i,:,:) * B'(matlab/octave)
are as diagonal as possible.Installation of Python packageTo install the package, do:$ pip install -U https://github.com/pierreablin/qndiag/archive/master.zipYou can also simply clone it, and then do:$ pip install -e .To check that everything worked, the command$ python -c 'import qndiag'should not return any error.Use with Matlab or OctaveSeeqndiag.mandtoy_example.min the foldermatlab_octave.CiteIf you use this code please cite:P. Ablin, J.F. Cardoso and A. Gramfort. Beyond Pham’s algorithm
for joint diagonalization. Proc. ESANN 2019.
https://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2019-119.pdf
https://hal.archives-ouvertes.fr/hal-01936887v1
https://arxiv.org/abs/1811.11433
Package: qnet-qsd
QNET-QSDA code-converter and simulation driver between QNET and QSDDevelopment of QNET-QSD happens onGithub.InstallationTo install the latest released version of QNET-QSD, run this command in your terminal:$pipinstallqnet_qsdThis is the preferred method to install QNET-QSD, as it will always install the most recent stable release.If you don’t havepipinstalled, thisPython installation guidecan guide
you through the process.To install the latest development version of QNET-QSD from the from theGithub.$pipinstallgit+https://github.com/mabuchilab/qnet_qsd.git@master#egg=qnet_qsdUsageTo use QNET-QSD in a project:import qnet_qsdHistory0.1.0 (2018-03-31)Initial release
Package: qNetTI
qNetTI: Quantum Network Topology InferrerPython tools and demos for inferring quantum network topology.See our preprint titled "Inferring Quantum Network Topology using Local Measurements" for detailshttps://arxiv.org/abs/2212.07987.Please review thedocumentationfor details regarding this project.Project Structure./src/qnetti- Application code../test- Unit tests for application code../script- Scripts for numerical experiments, data collection, and plotting../data- Stored data from numerical experiments../demos- User oriented notebooks demoing the application of our code../docs- Source code for generating the static documentation pages.
Package: qNetVO
qNetVO: The Quantum Network Variational OptimizerSimulate and optimize quantum communication networks using quantum computers.FeaturesQNetVO simulates quantum communication networks on differentiable quantum cicuits.
The cicuit parameters are optimized with respect to a cost function using automatic differentiation and gradient descent.
QNetVO is powered byPennyLane, an open-source framework
for cross-platform quantum machine learning.Simulating Quantum Communication Networks:Construct complex quantum network ansatzes from generic quantum circuit compenents.Simulate the quantum network on a quantum computer or classical simulator.Optimizing Quantum Communication Networks:Use our library of network-oriented cost functions or create your own.Gradient descent methods for tuning quantum network ansatz settings to minimize the cost.Quick StartInstall qNetVO:$ pip install qnetvoInstall PennyLane:$ pip install pennylane==0.29Import packages:import pennylane as qml
import qnetvo as qnetNoteFor optimal use, qNetVO should be used with PennyLane.
QNetVO is currently compatible with PennyLane v0.29.ContributingWe welcome outside contributions to qNetVO.
Please see theContributingpage for details and a development guide.How to CiteSeeCITATION.bibfor a BibTex reference to qNetVO.LicenseQNetVO is free and open-source.
The software is released under the Apache License, Version 2.0.
SeeLICENSEfor details.AcknowledgmentsWe thankXanadu, theUIUC Physics Department, and theQuantum Information Science and Engineering Network (QISE-Net)for their support of qNetVO.
Work funded by NSF award DMR-1747426.