Saravanan666/pypi-org huggingface dataset:
Package: qef
qefquasielastic fittingFree software: MIT licenseDocumentation:https://qef.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.3 (2018-04-10)Include only qef directory in release0.2.2 (2018-04-10)Exclude tests directory from release0.2.1 (2018-04-10)Include subdirectories of qef in release0.2.0 (2018-04-09)Notebook for global fitting (PR #40)Load Mantid Nexus data (PR #38)Tabulated resolution model (PR #43)0.1.0 (2017-12-13)First release on PyPI.
Package: qeijo
First of all,qeijois not an acronym. Okay, we have the Q and E for Quantum Espresso, for sure, but that's it.
The point was just to use a funny name for the package.qeijois an incorrect way - on purpose, of course - of spelling "queijo", which is simply the Portuguese word
for "cheese".This package contains a lightweight library that allows the user to launch electronic structure calculations with
Quantum Espresso and then collect the results, all done in a Pythonic way. Just to be clear, I don't
claim that this package can compete in terms of features with much larger frameworks for atomistic
simulations, like ASE. All you can expect fromqeijois that it is light and easy to use.In version 0.1, there is only one module,pw, which must be used to build an input to the pw.x program,
launch a total energy calculation and get from it important quantities, like the total energy of the
system, the relaxed atomic coordinates, magnetization, etc. In future releases, I plan to add interfaces
to other programs from the Quantum Espresso package, as well as work a bit more on user documentation.Basic Usage Example# Launching a calculation with pw.x of H2 molecule, reading the input from an existing input file
from qeijo import pw

cmd="mpirun -np 2 pw.x"
h2_calc=pw.calc()
h2_calc.read_input("h2.inp")
inpstr=h2_calc.build_input()
h2_out=h2_calc.run(command_line=cmd,input_string=inpstr,saveout=True,
                   outfile="h2.out",savecoords=True,coordfile="h2.xyz")

# Print the total energy in eV
print("Total energy: %f" % h2_out.energy[-1])

# Print the relaxed coordinates of the the two H atoms
print("H1: %f %f %f" % (h2_out.x[0],h2_out.y[0],h2_out.z[0]))
print("H2: %f %f %f" % (h2_out.x[1],h2_out.y[1],h2_out.z[1]))
Package: qemu-ga-exec
Command executor for QEMU Windows guestsThis package providesqemu-ga-execscript to run a command inside a Windows
guest using QEMU Guest Agent (GA). User must set up GA socket as described
inQEMU wiki.usage: qemu-ga-exec [-h] --connect CONNECT [--verbose] [--env NAME=VALUE]
                    [--path PATH] [--no-default-path] [--no-default-env]
                    COMMAND [COMMAND ...]

Command executor for QEMU Windows guests.

positional arguments:
  COMMAND               guest command

optional arguments:
  -h, --help            show this help message and exit
  --connect CONNECT, -c CONNECT
                        virtio-serial Unix socket path
  --verbose, -v         increase output verbosity
  --env NAME=VALUE, -e NAME=VALUE
                        guest environment variable
  --path PATH, -p PATH  guest PATH component
  --no-default-path, -P
                        do not prepend PATH with system folders
  --no-default-env, -E  do not prepend environment with default valuesThe script requires Python 3 with standard library only, as it utilizesQEMU GA protocol.
License is MIT.
Package: qemu-rpi-gpio
QEMU RPI GPIOSimulate GPIO in qemu-based Raspberry PiHow it worksThe script (qemu-rpi-gpio) present in this repository interacts with qemu
using the built-inqtestprotocol.Wrapping the protocol and interacting with the memory of the guest operating
system, it can set or reset the various GPIOs.Note:Vanilla qemu (5.1.93) will not handle GPIO interrupts, therefore
loading/sys/class/gpio/gpio$N/directionand waiting for an interrupt
will not do anything.To enable interrupt support you'll need to download and compilethis qemu fork.InstallationYou can install the script via pip withpip install qemu-rpi-gpioPrereqisitesYou needsocat,python3andpexpectlibrary to use this
script.These can be installed under ubuntu with:sudo apt install python3-pexpect socatTo download raspbian images you'll need 7zipsudo apt install p7zip-fullSetupDownload a raspbian image using./qemu-pi-setup/setup.shAfter this operation, execute the script to load the unix socket and make it
available to qemu./qemu-rpi-gpioYou will be prompted to an interactive shell, you can find the commands available
in theInteracting with gpiossection.In another terminal execute the./qemu-pi-setup/run.shscript, this will execute a virtual
raspberry pi and attach it to the gpio application.If you close the raspberry pi you can reload the socket using the commandreloadin the qemu-rpi-gpio prompt.Interacting with gpiosFirst of all, you need to export GPIOs in your guest Linux.
In a shell on your raspberry pi do:$ sudo su -
# echo 4 >/sys/class/gpio/export
# echo in >/sys/class/gpio/directionThe main commands in theqemu-rpi-gpioapplication are:commanddescriptionexampleget $Nget the value of GPIO $Nget 4set $N $Vset the value of GPIO $N to $V (1 or 0)set 4 1You can get the full list of commands usinghelpFor instance, let us set the value of the pre-exported gpio 4(gpio)> set 4 1Now you can read the value of your gpio# cat /sys/class/gpio/value
1If we set it to zero, it will be immediately reflected in the guest system(gpio)> set 4 0# cat /sys/class/gpio/value
0
Package: qencode
Inside this library you will find sample code for creatingvideo transcodingtasks, launching encoding jobs, video clipping and receiving callbacks. Updates are posted on a regular basis and we are open to any improvements or suggestions you may have.Some of the options Qencode offers for transcoding your videos at scale:Resolution8K4K1440p1080p720p480p360p240FeaturesThumbnailsWatermarkingVR / 360 EncodingSubtitles & CaptionsCreate ClipsVideo StitchingS3 StoragePreview ImagesCustom ResolutionCallback URLsCustom PresetsRotateAspect RatioNotificationsCrop VideosTransfer & Storage OptionsS3 QencodeAWSGoogle CloudBackblazeAzureFTPHTTP(S)VPN
Package: qencode3
Here you will find examples of Qencode solutions using the latest version of python. Some popular examples include launchingvideo encodingjobs through the API, basic testing functionality, and code developed to exhibit a wide range of features that we offer. Please send over any ideas you have to help us improve our solution and continue to provide you with the easiest transcoding solutions on the market.Key features of encoding your videos:Output FormatsHLSMPEG-DASHMP4MXFWebMCodecsH.264 (AVC1)H.265 (HEVC)VP9VP8AV1MPEG-2Input FormatsMP4AVIMOVMKVHLSMPEG‑2 (TS & PS)MXFASFProResXDCAMDNxFLV...and many more
Package: qepy
QEpy - Quantum ESPRESSO in PythonQEpyturns Quantum ESPRESSO (QE) into a Python DFT engine for nonstandard workflows.Contributors and fundingThe Quantum-Multiscale collaborationMain author:Xuecheng Shao(Rutgers)Oliviero Andreussi (UNT), Davide Ceresoli (CNR, Italy), Matthew Truscott (UNT), Andrew Baczewski (Sandia), Quinn Campbell (Sandia), Michele Pavanello (Rutgers)Thanks to ...The Quantum ESPRESSO developers for the QE codebaseNSF for funding the Quantum-Multiscale collaborationRequirementsPython(>=3.7)NumPy(>=1.18.0)f90wrap(>=0.2.8)Quantum ESPRESSO(=6.5)Compiler (GNU(Recommended) orIntel)InstallationPipUsing pip can easy install the release version (serial) of QEpy fromPyPI.python-mpipinstallqepySourceQEAll source codes should be compiled with the-fPICcompuiler option. Add-fPICto the configuration options. E.g.,./configureCFLAGS=-fPICFFLAGS=-fPICtry_foxflags=-fPICMPIF90=mpif90makeallexportqedir=`pwd`QEpygitclone--recurse-submoduleshttps://gitlab.com/shaoxc/qepy.gitoldxml=yesldau=yestddft=yespython-mpipinstall-U./qepyManual and TutorialsSeeQEpy's websitefor details.
Package: qe-rho
qeRhoThe module is to generate a charge density filecharge-density.datfor quantum espresso to read.to installpip install qe_rhoto use# import superposition of atomic density
from qe_rho import SAD

# initialize SAD density
rho = SAD('tests/pwscf.in')

# save charge-density.dat to folder pwscf.save
rho.saverhog('pwscf.save')

# output real-space charge density in a 3D numpy array
rhor = rho.rho_g2r()update log2022-07-16addedmeshplot.pwscfplot, plot SAD and converged charge density and difference between them.TODOHDF5 supportspin support
Package: qermit
Qermitqermitis a python module for running error-mitigation protocols on quantum processors usingpytket, the Cambridge Quantum python module for interfacing withCQCTKET, a set of quantum programming tools.This repo containts API documentation, a user manual for getting started withqermitand source code.Getting Startedqermitis compatible with thepytket1.0 release and so is available for Python 3.9, 3.10 and 3.11 on Linux, MacOS and Windows.
To install, run:pip install qermitAPI documentation can be found atcqcl.github.io/Qermit.To get a more in depth explanation of Qermit and its features including how to construct custom methods see themanualwhich includes examples.BugsPlease file bugs on the Githubissue tracker.How to citeIf you wish to cite Qermit in any academic publications, we generally recommend citing ourbenchmarking paperfor most cases.ContributingPull requests or feature suggestions are very welcome. To make a PR, first fork the repo, make your proposed
changes on themainbranch, and open a PR from your fork. If it passes
tests and is accepted after review, it will be merged in.Code styleFormattingAll code should adhere toflake8formatting, ignoring only E501 and W503Type annotationOn the CI,mypyis used as a static
type checker and all submissions must pass its checks. You should therefore runmypylocally on any changed files before submitting a PR.TestsTo run the tests:cdinto thetestsdirectory;ensure you have installedpytest;runpytest.When adding a new feature, please add a test for it. When fixing a bug, please
add a test that demonstrates the fix.
Package: qeschema
Theqeschemapackage provides tools for
converting XML data produced by the Quantum ESPRESSO suite of codes (ESPRESSO:
opEn-Source Package for Research in Electronic Structure, Simulation and Optimization).RequirementsPython3.7+xmlschema(Python library for processing XML Schema based documents)InstallationYou can install the library withpipin a Python 3.7+ environment:pip install qeschemaIf you need HDF5 utilities and/or the YAML format, install the extra
features using the appropriate command from these alternatives:pip install qeschema[HDF5]
pip install qeschema[YAML]
pip install qeschema[HDF5,YAML]UsageDefine you data document using:>>>importqeschema>>>pw_document=qeschema.PwDocument()and then read XML data from a file processed by the corresponding application of
Quantum ESPRESSO suite:>>>pw_document.read("tests/examples/pw/Al001_relax_bfgs.xml")Loaded data can be decoded to Python data dictionary or written to JSON or YAML formats:>>>xml_data=pw_document.to_dict()>>>json_data=pw_document.to_json()AuthorsDavide BrunatoPietro DelugasGiovanni BorghiAlexandr FonariLicenseThis software is distributed under the terms of the MIT License.
See the file ‘LICENSE’ in the root directory of the present
distribution, orhttp://opensource.org/licenses/MIT.
Package: qetools
QEToolsIt is a command line helper to run comman quantum espresso calculations.Usage:qetools -c [CALCULATION] [OTHER ARGS]Info:By default PBE, PBESOL and LDA (all ONCV) pseudo-potentials are downloaded.Arguments:-c [CALCULATION]encut, kgrid, vacuum- respective convergences.vc-relax- variable cell relaxation.pressure- to get structure at required (compressed) pressure.- *-rp* required pressure in kbars.

- *-ic* intial compression factor (default 0.9).eos- fits equation of state using ASE.- *-ns* number of structures to consider for fitting (default 10).harmonic- energy vs. displacement plot for selected atoms in selected directions.- *-aid* index of atom(s) to displace, by default all unique atoms will be displaced.

- *-dd* direction of displacement, default ( -dd 0 1 2 ).scf- single point energy calculation (All the below calculations require completed 'scf' calculation).nscf- to be done after 'scf' calculation, with finer grid.bands- electronic band structure calculation, by default ase.dft.bandpath will be used, saves plot.dos- electronic dos calculation, saves plot.ph_pre- setting up phonon calculation (must).ph_mid- creates a script which can be run on multiple jobs for ph.x calcuations.ph_post- after ph_mid or ph_pre, completes phonon calculation, returns flfrc file.ph_bands- phonon bandstructure.ph_dos- phonon density of states.epw_pre- setting up for EPW calculation (to be done after 'scf', 'ph_post').epw_post- Performs EPW calculation.Others-e [ENCUT][Ry](default 50).-k [KGRID](default 4 4 4).-v [VACUUM][ANG](default 10)
*-vdrvacuum direction 1,2,3 for x,y,z direction (must for vacuum calcs)-t [THRESHOLD](default 0.01)-ppn [NODES](default available/2)-ppd [PSEUDOPOTENTIAL DIRECTORY]lda, pbe, pbesol can be used to use default potentials. Otherwise expects path where PPs are present in the format 'Cu.UPF' (default pbe).-fASE readable structure file.-emin, -emaxy-axis limits for electronic bandstructure plot.-asracoustic sum rule for ph_post, (default simple).-nqnumber of q(k) points in bandstructures.-bpbandpath for bandstructures like 'GXLMK', default from ase.bandpath.-npoolnpool for epw related calcs.-parparameters file in the following format (for pw.x, ph.x, dos.x, epw.x)ecutwfc 80
calculation scf
...Example: qetools -c scf -e 80 -k 4 4 4 -f si.cif -ppd lda -ppn 8 -par parameters.txt
Package: qexpy
QExPy (Queen’s Experimental Physics) is a Python 3 package designed to facilitate data analysis in undergraduate physics laboratories. The package contains a module to easily propagate errors in uncertainty calculations, and a module that provides an intuitive interface to plot and fit data. The package is designed to be efficient, correct, and to allow for a pedagogic introduction to error analysis. The package is extensively tested in the Jupyter Notebook environment to allow high quality reports to be generated directly from a browser.
Package: qfa
Quantum Finite AutomataThis library provides implementations of multiple quantum finite automata
models.Implemented automata modelsPFA- Probabilistic Finite AutomatonMO1QFA- Measure-Once Quantum Finite AutomatonMM1QFA- Measure-Many Quantum Finite AutomatonGQFA- General Quantum Finite AutomatonHelper modulesLanguageChecker- used to check a language against an automaton using
multiple acceptance conditionsLanguageGenerator- generates language samples from regular expressionsPlotter- plots the results obtained from running a LanguageCheckerHereis the modules' overview in polish.CitationIf you have used our library and and would like to cite its usage, we please use the following BibTeX entry. Thanks!@article{lippa2020simulations,
  title={Simulations of Quantum Finite Automata.},
  author={Lippa, G and Makie{\l}a, K and Kuta, M},
  journal={Computational Science--ICCS 2020},
  volume={12142},
  pages={441--450},
  year={2020}
}
Package: qfaas
qfaas-libqfaas-lib is a supporting library for QFaaS Serverless framework for Quantum Computing.InstallationInstall qfaas-lib with pip (Python >=3.10)pipinstallqfaasUsage/ExamplesfromqfaasimportBackend,RequestData,Utils#Definesdknamesdk="braket"#Pre-processinginputdatadefpre_process(input):data=RequestData(input,sdk)returndata#Post-processingoutputdatadefpost_process(job):output=Utils.counts_post_process(job)returnoutputdefhandle(event,context):#1.Pre-processingrequestData=pre_process(event)#2.GenerateQuantumCircuitqc=generate_circuit(requestData.input)#3.VerifyandgetBackendinformationbackend=Backend(requestData,qc)#4.Submitjobandwaitupto1minforjobtocomplete.job=backend.submit_job(qc)#5.Post-processifjob.jobResult:job=post_process(job)response=Utils.generate_response(job)#6.SendbacktheresultreturnresponseAuthorsHoa NguyenDocumentationTBA
Package: qface-qtro
# QFace QtRemoteObjects GeneratorWork In ProgressThis generator tries to generate a complete micro service solution. It does so by
reading the QFace IDL file and generating a client side plugin and a service
for each interface. Each module will be bundled into one server with an own
service registry where all interfaces from the module will be available.As a user you can simply import the QML generated plugin and ensure the server
side generated stub is being implemented.The QML plugin will automatically connect to the server, which needs to run
when the plugin is loaded.Each interface service is accessible using the fully qualified name. Different
than the REPC the models are also integrated into the service interface as
described via the QFace IDL.Open Issues:
- Ideally the client side has a mean to start the server on demand.
- What happens if the customer would like to have only one service registry for all
modules (e.g. the whole system)?
Package: qfactor
Quantum Fast Circuit Optimizer (Qfactor)This optimizer can optimize the distance between a circuit, a sequence of
unitary gates, and a target unitary matrix. This optimizer uses an analytic
method based on the SVD operation.InstallationThe best way to install this python package is with pip.pip install qfactorUsageThe qfactor package can be used to optimize a specified circuit.
You can specify your circuit with a list of Gate objects and pass them to
the optimize function. Seean example.CopyrightQuantum Fast Circuit Optimizer (qFactor) Copyright (c) 2020, The
Regents of the University of California, through Lawrence Berkeley
National Laboratory (subject to receipt of any required approvals
from the U.S. Dept. of Energy). All rights reserved.If you have questions about your rights to use or distribute this software,
please contact Berkeley Lab's Intellectual Property Office atIPO@lbl.gov.NOTICE.  This Software was developed under funding from the U.S. Department
of Energy and the U.S. Government consequently retains certain rights.  As
such, the U.S. Government has been granted for itself and others acting on
its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
Software to reproduce, distribute copies to the public, prepare derivative
works, and perform publicly and display publicly, and to permit others to do so.
Package: qfast
QFAST: Quantum Fast Approximate Synthesis ToolQFAST is a quantum synthesis tool designed to produce short circuits and to scale well in practice. QFAST uses a mathematical model of circuits encoding both gate placement and function. This is packaged together with a hierarchical stochastic gradient descent formulation that combines “coarse-grained” fast optimization during circuit structure search with a better, but slower, stage only in the final circuit refinement.InstallationThe best way to install this python package is with pip.pip install qfastUsageQFAST can be used to convert a quantum operation specified by a unitary matrix into a circuit given byopenqasmcode. There is a command-line interface provided with qfast that can be accessed bypython -m qfast. This can be used to synthesize a matrix.python -m qfast input.unitary output.qasmHere theinput.unitaryfile is a NumPy matrix saved withnp.savetxt, the qasm output will be saved in theoutput.qasmfile and the KAK native tool will be used. The command-line help optionpython -m qfast -hcan be used for further information.QFAST can also be used as a library,an exampleis included.Native ToolsNative tools are necessary for QFAST to perform instantiation. During decomposition, the input unitary matrix is hierarchically broken into many smaller unitaries. At some level in the hierarchy, QFAST switches to instantiation, which uses a native synthesis tool to convert the small unitaries into native gates.Included with this python package is the QSearch native tool. Here are some others:qfast-qiskit: Several qiskit toolsqfast-uq: A UniversalQCompiler native tool (deprecated)qfast-qs: A QSearch native tool (Now default)ReferencesYounis, Ed, et al. "QFAST: Quantum Synthesis Using a Hierarchical Continuous Circuit Space." arXiv preprint arXiv:2003.04462 (2020).CopyrightQuantum Fast Approximate Synthesis Tool (QFAST) Copyright (c) 2020,
The Regents of the University of California, through Lawrence Berkeley
National Laboratory (subject to receipt of any required approvals from
the U.S. Dept. of Energy). All rights reserved.If you have questions about your rights to use or distribute this software,
please contact Berkeley Lab's Intellectual Property Office atIPO@lbl.gov.NOTICE.  This Software was developed under funding from the U.S. Department
of Energy and the U.S. Government consequently retains certain rights.  As
such, the U.S. Government has been granted for itself and others acting on
its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
Software to reproduce, distribute copies to the public, prepare derivative
works, and perform publicly and display publicly, and to permit others to do so.
Package: qfast-qiskit
QFAST-QISKit: QISKit Plugin for QFASTQFAST-QISKit packages several QISKit tools forQFAST.
There are two native tools, KAKTool and QiskitTool, that are included.
Also, QiskitCombiner is a recombination tool that uses qiskit to
piece together small circuits. The QiskitCombiner provides circuit optimization
that isn't available with the default NaiveCombiner.InstallationThe best way to install this python package is with pip.pip install qfast-qiskitCopyrightQuantum Fast Approximate Synthesis Tool (QFAST) Copyright (c) 2020,
The Regents of the University of California, through Lawrence Berkeley
National Laboratory (subject to receipt of any required approvals from
the U.S. Dept. of Energy). All rights reserved.If you have questions about your rights to use or distribute this software,
please contact Berkeley Lab's Intellectual Property Office atIPO@lbl.gov.NOTICE.  This Software was developed under funding from the U.S. Department
of Energy and the U.S. Government consequently retains certain rights.  As
such, the U.S. Government has been granted for itself and others acting on
its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
Software to reproduce, distribute copies to the public, prepare derivative
works, and perform publicly and display publicly, and to permit others to do so.
Package: qfast-qs
QFAST-QS: QSearch Plugin for QFASTQFAST-QS packages the SearchCompiler as a native tool plugin forQFAST. This package imports the QSearch Compiler which can be foundhereand its licensehere.InstallationThe best way to install this python package is with pip.pip install qfast-qsCopyrightQuantum Fast Approximate Synthesis Tool (QFAST) Copyright (c) 2020,
The Regents of the University of California, through Lawrence Berkeley
National Laboratory (subject to receipt of any required approvals from
the U.S. Dept. of Energy). All rights reserved.If you have questions about your rights to use or distribute this software,
please contact Berkeley Lab's Intellectual Property Office atIPO@lbl.gov.NOTICE.  This Software was developed under funding from the U.S. Department
of Energy and the U.S. Government consequently retains certain rights.  As
such, the U.S. Government has been granted for itself and others acting on
its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
Software to reproduce, distribute copies to the public, prepare derivative
works, and perform publicly and display publicly, and to permit others to do so.