Saravanan666/pypi-org huggingface dataset:
Package: qfast-sc
QFAST-SC: SearchCompiler Plugin for QFASTQFAST-SC packages the SearchCompiler as a native tool plugin forQFAST. This package imports the SearchCompiler which can be foundhereand its licensehere.InstallationThe best way to install this python package is with pip.pip install qfast-scCopyrightQuantum 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-uq
QFAST-UQ: UniversalQ Compiler Plugin for QFASTQFAST-UQ packages the qiskit's implementation of isometry decomposition as a native tool plugin forQFAST.InstallationThe best way to install this python package is with pip.pip install qfast-uqCopyrightQuantum 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: qf-diamond-norm
QuantumFlow Diamond NormGavin E. Crooks (2020)SourceCalculation of the diamond norm between two completely positive trace-preserving (CPTP) superoperators, using
theQuantumFlowpackageThe calculation uses the simplified semidefinite program of WatrousarXiv:0901.4709[J. Watrous,Theory of Computing 5, 11, pp. 217-238
(2009)]Kudos: Based on MatLab code written byMarcus P. da SilvaInstallationNote: Diamond norm requires that the "cvxpy" package (and dependencies) be fully installed. Installing cvxpy via pip
does not correctly install all the necessary packages.$ conda install -c conda-forge cvxpy
$ git clone https://github.com/gecrooks/qf_diamond_norm.git
$ cd qf_diamond_norm
$ pip install -e .Example> import quantumflow as qf
    > from qf_diamond_norm import diamond_norm
    > chan0 = qf.random_channel([0, 1, 2]) # 3-qubit channel
    > chan1 = qf.random_channel([0, 1, 2])
    > dn = diamond_norm(chan0, chan1)
    > print(dn)
Package: qff
QFF: Quantize Financial FrameworkQFFis a Python package of quantitative financial framework, which is used to provide a localized backtesting and simulation trading environment for individuals, so that users can focus more on trading strategy writing.Main FeaturesHere are just a few of the things that QFF does well:Provide one-stop solutions such as data crawling, data cleaning, data storage, strategy writing, strategy analysis, strategy backtest and simulated trade.Provide graceful interface for strategy writing (similar to JoinQuant), facilitate users to get started quickly.Provide a local running environment to improve the strategy running efficiency.Provide rich interfaces to obtain free stock data, such as fundamental data, real-time and historical market data etc.Provide practical auxiliary functions to simplify strategy writing, such as indicator calculation, trading system framework, etc.InstallationSource codeThe source code is currently hosted on GitHub at:https://github.com/haijiangxu/qffGeneralpipinstallqff--upgradeChinapipinstallqff-ihttp://mirrors.aliyun.com/pypi/simple/--upgradeDockerDocker image for the QFF is athttps://hub.docker.com/r/haijiangxu/qff.pull docker imagedockerpullqffrun docker imagedockerrun-d-v/root/xxxx:/root/work-p8765:8765qffDocumentDocumentation for the latest Current release is athttps://qff.readthedocs.io/zh_CN/latest/.ContributionQFF is still under developing, feel free to open issues and pull requests:Report or fix bugsRequire or publish interfaceWrite or fix documentationAdd test casesStatementQFF only supports stocks, but not other financial products such as futures, funds, foreign exchange, bonds, cryptocurrencies, etc.All data provided by QFF is just for academic research purpose.The data provided by QFF is for reference only and does not constitute any investment proposal.Any investor based on QFF research should pay more attention to data risk.QFF will insist on providing open-source financial data.Based on some uncontrollable factors, some data interfaces in QFF may be removed.Please follow the relevant open-source protocol used by QFF.AcknowledgementSpecial thanksQUANTAXISfor the opportunity of learning from the project;Special thanksAKSharefor the opportunity of learning from the project;Special thanksJoinQuantfor the opportunity of learning from the project;
Package: qfieldcloud-sdk
The official QFieldCloud SDK and CLIqfieldcloud-sdkis the official client to connect to QFieldCloud API either as a python module, or directly from the command line.ContentsInstallationCLI usageModule usageInstallLinux/macOSpip3 install qfieldcloud-sdkWindowsInstall Python with your favorite package manager. Then:python -m pip install qfieldcloud-sdkCLI usageThe package also ships with the official QFieldCloud CLI tool.Usageqfieldcloud-cli [OPTIONS] COMMAND [ARGS]...Examples# logs in user "user" with password "pass"qfieldcloud-cliloginuserpass# gets the projects of user "user" with password "pass" at "https://localhost/api/v1/"qfieldcloud-cli-uuser-ppass-Uhttps://localhost/api/v1/list-projects# gets the projects of user authenticated with token `QFIELDCLOUD_TOKEN` at "https://localhost/api/v1/" as JSONexportQFIELDCLOUD_URL=https://localhost/api/v1/exportQFIELDCLOUD_TOKEN=017478ee2464440cb8d3e98080df5e5a
qfieldcloud-cli--jsonlist-projectsMore detailed documentation can be foundhereModule usagefromimportsdkclient=sdk.Client(url="https://app.qfield.cloud/api/v1/")client.login(username="user1",password="pass1",)projects=client.list_projects()>projectsProjects:0myusername/myproject11myusername/myproject2...DevelopmentContributions are more than welcome!Code styleCode style done withprecommit.pip install pre-commit
# if you want to have git commits trigger pre-commit, install pre-commit hook:
pre-commit install
# else run manually before (re)staging your files:
pre-commit run --all-filesCloning the projectOne time action to clone and setup:gitclonehttps://github.com/opengisch/qfieldcloud-sdk-pythoncdqfieldcloud-sdk-python# install dev dependenciespython3-mpipinstallpipenv
pre-commitinstall# install package in a virtual environmentpipenvinstall-rrequirements.txtTo run CLI interface for development purposes execute:pipenvshell# if your pipenv virtual environment is not active yetpython-mqfieldcloud_sdkTo ease development, you can set a.envfile. Therefore you can use directly theqfieldcloud-cliexecutable:cp .env.example .env
pipenv run qfieldcloud-cliBuilding the package# make sure your shell is sourced to no virtual environmentdeactivate# buildpython3-mbuild# now either activate your shell withpipenvshell# and install withpython-mpipinstall.--force-reinstall# or manually ensure it's pipenv and not your global pip doing the installationpipenvrunpipinstall.--force-reinstallVoilà!
Package: qfinance
QFinanceCopyright (c) 2023 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.About QFinanceQFinanceis a Quantum Finance library based on theQComputeSDK. It provides a set of tools for building quantum algorithms for finance. Currently, it supports the following features:Pricing European options using Quantum Monte Carlo methodPricing European options using classical methods, includingBlack-Scholes-Merton methodClassical Monte Carlo methodThe following quantum algorithms are implemented inQFinance:Quantum Monte Carlo algorithm for simple piecewise linear payoff functionArbitrary quantum state preparationQuantum Fourier transformQuantum phase estimationQuantum amplitude estimation algorithms:Canonical Quantum Amplitude Estimation [Brassard 2002]Maximum Likelihood Amplitude Estimation [Suzuki 2019]Iterative Quantum Amplitude Estimation [Grinko 2019]InstallationQFinance is available on PyPI. To install the latest release, run:pipinstallqfinancepipwill handle all dependencies automatically.ExamplesOption PricingimportQComputeQCompute.Define.Settings.outputInfo=FalsefromQFinance.pricingimportEuropeanOptionPricingClassical,EuropeanCallQMC# set parameters# s0 is the current price of the underlying asset# k is the strike price# t is the time to maturity (in years)# r is the risk-free interest rate# sigma is the volatility of the underlying assets0=100k=90t=1r=0.05sigma=0.1########################################################################################option_classical=EuropeanOptionPricingClassical(s0,k,t,r,sigma,"call","long")# option price calculated by Black-Scholes-Merton modelbsm_price=option_classical.bsm_price()option_classical.set_CMC_sample_size(1000000)# option price calculated by Classical Monte Carlo methodcmc_price=option_classical.cmc_price()option_classical.show_info()########################################################################################option=EuropeanCallQMC(s0,k,t,r,sigma)option.set_num_qubits(3)option.set_scaling(0.04)# set MLAE configurationoption.method="MLAE"Q_powers=[2,3,5,10]shots=[100000]*len(Q_powers)price_qmc=option.get_price_mlae(Q_powers,shots)print(f"BSM price:\t{bsm_price:.5f}")print(f"CMC price:\t{cmc_price:.5f}")print(f"QMC price:\t{price_qmc:.5f}")The typical output is as follows:Europeanoptionpricingwiththefollowingparameters:
optiontype:call,long
currentstockprice:s0=100strikeprice:k=90timetomaturity(inyears):t=1risk-freeinterestrate:r=0.05
volatility:sigma=0.1===================RunningMLAEalgorithm======================powersofQare:[2,3,5,10]numberofshotsare:[100000,100000,100000,100000]ApplyingQ^2tothestateA|0>^8...
Timeelapsed:0.2348seconds.

ApplyingQ^3tothestateA|0>^8...
Timeelapsed:0.3460seconds.

ApplyingQ^5tothestateA|0>^8...
Timeelapsed:0.5540seconds.

ApplyingQ^10tothestateA|0>^8...
Timeelapsed:1.0420seconds.=====================MLAEalgorithmfinished.====================BSMprice:14.62884
CMCprice:14.62937
QMCprice:14.62056LicenseQFinance uses theApache License 2.0.
Package: qf-lib
QF-LibWhat is QF-lib?QF-Libis a Python library that provides high quality tools for quantitative finance.
A large part of the project is dedicated to backtesting investment strategies.
The Backtester uses anevent-driven architectureand simulates events such as daily market opening
or closing. It is designed totest and evaluate any custom investment strategy.Main features include:Flexible data sourcing - the project supports the possibility of an easy selection of the data source. Currently provides financial data fromBloomberg,Quandl,Haver AnalyticsorPortara. To check if there are any additional dependencies necessary for any of these data providers please visitthe installation guide.Tools to prevent look-ahead bias in the backtesting environment.Adapteddata containers, which extend the functionality of pandasSeries'andDataframes.Summary generation - all performed studies can be summarized with a practical and informative document explaining the results.Several document templatesare available in the project.Simple adjustment of existing settings and creation of new functionalities.InstallationYou can installqf-libusing the pip command:pipinstallqf-libAlternatively, to install the library from sources, you can download the project and in the qf_lib directory
(same one where you found this file after cloning the repository) execute the following command:pythonsetup.pyinstallPrerequisitesThe library usesWeasyPrintto export documents to PDF. WeasyPrint requires additional dependencies, check theplatform-specific instructions for Linux, macOS and Windows installation.In order to facilitate the GTK3+ installation process for Windows you can usefollowing installers. Download and run the latestgtk3-runtime-x.x.x-x-x-x-ts-win64.exefile to install the GTK3+.DocumentationInstallation guide:https://qf-lib.readthedocs.io/en/latest/installation.htmlConfiguration guide:https://qf-lib.readthedocs.io/en/latest/configuration.htmlAPI documentation:https://qf-lib.readthedocs.io/
Package: qfmu
qfmuis a python package to generatecontinuous-time,LTIsystem FMUs from command line.InstallationInstallqfmuthrough PyPIpip install qfmuNotedthat a C compiler is requiredmsvcfor Windowsgccfor Linuxclangfor MacOSFeaturesCurrently, qfmu is able to generate fmus that are compliant withFMI2standard.The following models are supported:ModelMECSState Space (ss)✔️✔️Transfer Function (tf)✔️✔️ZeroPoleGain (zpk)✔️✔️PID (pid)✔️✔️Notedthat only continuous-time models are supported currently.ExamplesGenerate a continuous-time state space FMUqfmuss-A"[[1,2],[3,4]]"-B"[[1],[2]]"-C"[[1,0],[0,1]]"-x0"[3.14, 6]"-o./example_ss.fmuIfqfmuis installed properly, you should see aexample_ss.fmufile generated in your current working directory.If you havefmpyinstalled, you can runfmpy info example_ss.fmuto see detailed model information.Model Info

  FMI Version        2.0
  FMI Type           Model Exchange, Co-Simulation
  Model Name         q
  Description        None
  Platforms          c-code, linux64
  Continuous States  2
  Event Indicators   0
  Variables          10
  Generation Tool    qfmu
  Generation Date    2023-10-08 21:24:32.733857

Default Experiment

  Stop Time          1.0
  Tolerance          0.0001

Variables (input, output)

  Name               Causality              Start Value  Unit     Description
  u1                 input                          0.0           Model input 1
  y1                 output                                       Model output 1
  y2                 output                                       Model output 2Generate a continuous-time transfer function FMU using thenumerator,denominatorrepresentation: $\frac{s}{s+1}$qfmutf--num"[1]"--den"[1,1]"-o./example_tf.fmuGenerate a continuous-time transfer function FMU using thezero-pole-gainrepresentation: $\frac{0.5(s-1)}{(s+1)(s+2)}$qfmuzpk-z"[1]"-p"[-1, -2]"-k0.5-o./example_zpk.fmuGenerate a continuous-time PI controller FMU: $3 + \frac{0.1}{s}$qfmupid--kp=3.0--ki=0.1-o./example_pid.fmu
Package: qforce
Quantum Mechanically augmented molecularforcefieldsPlease see theDocumentation.If you use Q-Force, please cite:Sami, S.; Menger, M. F. S. J.; Faraji, S.; Broer, R.; Havenith, R. W. A., Q-Force: Quantum Mechanically Augmented Molecular Force Fields. Journal of Chemical Theory and Computation 2021, 17 (8), 4946-4960.
Package: qformatpy
IntroductionWelcome to the qformat Python library, a powerful tool for formatting floating-point
numbers into fixed-point representation with Q notation.This library supports ARM’s Q format, where QI includes the sign bit.The main function, qformat, allows users to specify the number of integer bits (QI),
fractional bits (QF), whether the number is signed or unsigned, and provides flexibility
in choosing rounding and overflow handling methods.Whether you’re working on embedded systems, signal processing, or any application requiring fixed-point
representation, qformat is here to streamline the process.The example below shows pi being converter to the sQ4.8 format, using Truncation as the
rounding method:>>>fromqformatpyimportqformat>>>x=3.141592653589793>>>result=qformat(x,qi=4,qf=8,rnd_method='Trunc')>>>resultarray([3.140625])InstallationThe qformatpy library is available via PIP install:python3-mvenvpyenvsourcepyenv/bin/activatepipinstallqformatpyImport the package as shown below:importqformatpyExample usage>>>importnumpyasnp>>>importqformatpy>>>test_array=np.array([1.4,5.57,3.14])>>>qformatpy.rounding(test_array,'TowardsZero')array([1,5,3])>>>qformatpy.rounding(test_array,'HalfDown')array([1,6,3])LinksDocumentation:https://qformatpy.readthedocs.io/en/latest/
Package: qformer
QformerImplementation of Qformer from BLIP2 in Zeta Lego blocks. The implementation is here straight from Figure 2. In particular the image block and text block.Installpip3 install qformerUsageimporttorchfromqformerimportQFormerx=torch.randn(1,32,512)# Create a random tensor of shape (1, 32, 512)img=torch.randn(1,32,512)# Create another random tensor of shape (1, 32, 512)qformer=QFormer(512,8,8,0.1,2,2)# Create an instance of the QFormer modely=qformer(x,img)# Apply the QFormer model to the input tensors x and imgprint(y.shape)# Print the shape of the output tensor yLicenseMITCitation@misc{li2023blip2,
    title={BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models}, 
    author={Junnan Li and Dongxu Li and Silvio Savarese and Steven Hoi},
    year={2023},
    eprint={2301.12597},
    archivePrefix={arXiv},
    primaryClass={cs.CV}
}
Package: qfp
QfpQfp is a python library for creating audio fingerprints that are robust to alterations in pitch and speed. This method is ideal for ID'ing music from recordings such as DJ sets where the tracks are commonly played at a different pitch or speed than the original recording. Qfp is an implementation of the audio fingerprinting/recognition algorithms detailed in a 2016 academic paper by Reinhard Sonnleitner and Gerhard Widmer[1].NOTE: This is a fork ofhttps://github.com/mbortnyck/qfp/which incorporates:multiple bug fixesPython 3 compatibiltymodern packaging with PoetryThis is all in service of having a convient audio fingerprinting service
for a website I'm working on.QuickstartInstall by downloading it from PyPI.pipinstallqfpYou can create a fingerprint from your reference audio...fromqfpimportReferenceFingerprintfp_r=ReferenceFingerprint("Prince_-_Kiss.mp3")fp_r.create()...or a query fingerprint from an audio clip that you wish to identify.fromqfpimportQueryFingerprintfp_q=QueryFingerprint("unknown_audio.wav")fp_q.create()The QfpDB can store reference fingerprints...fromqfp.dbimportQfpDBdb=QfpDB()db.store(fp_r,"Prince - Kiss")... and look up query fingerprints.fp_q=QueryFingerprint("kiss_pitched_up.mp3")fp_q.create()db.query(fp_q)print(fp_q.matches)[Match(record=u'Prince - Kiss',offset=0,vScore=0.7077922077922078)]Qfp currently accepts recordings inany format that FFmpeg can handle.DependenciesFFmpeg -https://github.com/FFmpeg/FFmpegNumPy -https://github.com/numpy/numpyPydub -https://github.com/jiaaro/pydubSciPy -https://github.com/scipy/scipySQLite -https://www.sqlite.org/[1]	R. Sonnleitner and G. Widmer, "Robust quad-based audio fingerprinting," IEEE/ACM Transactions on Audio, Speech and Language Processing (TASLP), vol. 24, no. 3, pp. 409–421, Jan. 2016. [Online]. Available:http://ieeexplore.ieee.org/abstract/document/7358094/. Accessed: Nov. 15, 2016.
Package: qfracture
Overviewqfracture is a Qt based front end exposing a fracture project. The interface
allows for data browsing and searching as well as data interaction.For full details on fracture please see:https://github.com/mikemalinowski/fractureBrowsingqFracture displays a browsing panel which allows you to navigate data in a
natural way - which is particularly useful if your data is file based.Right clicking aData Assetexposes the functionality bound to that data.SearchingWithin qFracture you can perform searches against your dataset. Fracture is
very quick at resolving searches - so this can be a preferable mechanism
when interacting with data if you have a reasonable idea of what you're looking
for.When no search entries are present this view will show anyData Elementswhich
you have marked as being favourites - allowing them to be accessed very quickly
with no overhead.Setting up a ProjectThe qFracture UI offers a wizard to make it easy to setup a new fracture
project. This guides you through the process of defining the data structure
location, the plugin locations and where you want to save your project file.It will also initiate a short scan of your data location. Depending on how
big your data set this can take a little time.Upon completion your data set is entirely searchable.System TrayThe qFracture Ui only performs a deep scan during the first time setup. Beyond
that, each location is re-scanned as you traverse those locations through the
browser panel.If you want time based scans to occur you can trigger theSystem Trayapplication (which is launchable from theSettingstab). The system tray
allows you to specify an interval time (in seconds), and enable or disable
timed scans.This approach allows the scanning to occur in a completely different process
to any qFracture instances which can aid performance, especially if you're
running qFracture from within environments such as Maya or Max etc.CollaborationI am always open to collaboration, so if you spot bugs lets me know, or if
you would like to contribute or get involved just shout!CompatibilityLaunchpad has been tested under Python 2.7 and Python 3.7 on Windows and Ubuntu.
Package: qfunction
QfunctionLibrary for researcher with statistics and mechanics equation non-extensive 📈📊📚Non-extensive worksThis package is for development and works using the deformed non-extensive algebra, using for calculus, the simple algebra and the specials functions from quantum mechanics and theoretical physic, on the non-extensive mode.The all functions and equation on this work, is based in the articles and papers fromDr. Bruno G. da Costa, your friend, thePhD Ignácio S. Gomesand others peoples and articles about the non-extensive works.Installation:this lib is found on the site of packages for python thepypiand on the site that is a repository for the codes and softwares with licenses from majority business of the word, thegithub.Linux$pipinstallqfunction-UWindowsC\:> py -m pip install qfunction -UExamplesfundamentalssimple algebrafromqfunction.fundamentals.canonicimportprodfromqfunction.fundamentalsimportq_sum,q_mult,q_ln,q_sub#the sum deformed on q=1print(q_sum(4,2,1,q=1))#output: 6#the sum deformed on q=1.9print(q_sum(4,2,1,q=1.9))#output: -0.200000000000351#the multiplication deformed on q=1print(q_mult(1,2,q=1))#output: 2#the multiplication deformed on q=.8print(q_mult(1,2,q=.8))#output: 1.9999999999999998#the natural logarithm on q=1print(q_ln(3,q=1))#output: 1.0984848484848484#the natural logarithm deformed on q=.5print(q_ln(3,q=.5))#output: 1.4641016151377162print(q_sub(4,3,q=.9))Quantumcreating a quantum circuit basefromqfunction.quantumimportQuantumCircuitasQcq=1.qc=Qc(4,q=q)qc.Y(2)qc.H(2,1)qc.med(2)#print(qc)any equationsfromqfunction.quantum.equationsimportS,S_qfromqfunction.fundamentalsimportq_cos,q_sinfromnumpyimportarray,linspace,pit=array([1,2,34,56,34,23])p=t/t.sum()#print(p)#print(S(p))t=linspace(-2,2,100)*2*pitheta=t/2gamma=tq=1## testing the entropy deformed  ##print(S_q(theta,gamma,q))q=.5print(S_q(theta,gamma,q))q=1.5print(S_q(theta,gamma,q))Algorithmsone simlpe example of code game on quantum circuit deformedfromqfunction.quantumimportQuantumCircuitasQcfromqfunction.quantum.algorithmsimportArenaGameq=.9qc=Qc(1,q=q)game=ArenaGame(qc=qc)game.up()game.left()game.left()game.show()Others Examples on colab.