Saravanan666/pypi-org huggingface dataset:
Package: pyqrack-cuda
pyqrackPure Python bindings for the pure C++11/OpenCL Qrack quantum computer simulator library(PyQrackis just pure Qrack.)To use this package, it's helpful to be familiar withvm6502q/qrack. Users gainmuchmore control over options by buildingvm6502q/qrackandvm6502q/pyqrackfrom source. For advanced users, building from source is the intended primary method ofPyQrackpackage distribution and use.Import and instantiateQrackSimulatorinstances. This simulator can perform arbitrary single qubit and controlled-single-qubit gates, as well as other specific gates likeSWAP.Any 2x2 bit operator matrix is represented by a list of 4complexfloating point numbers, inrow-major order.Single and array "b" parameters representPauli operator bases. They are specified according to the enumeration of thePauliclass.MC[x]andMAC[x]methods are controlled single bit gates, with as many control qubits as you specify via Python listcargument.MCXis multiply-controlled Pauli X, andMACXis "anti-"controlled Pauli X, i.e. "anti-control" activates the gate if all control bits are specificallyoff, as opposed toon.The package installation directory contains aqrack_cl_precompilefolder with executables for supported platforms, to compile OpenCL kernels once, beforehand, avoiding the need to recompile "just-in-time" every time that you load this package in a Python interpreter. If you no longer want to use precompiled kernels, or if precompilation fails, just delete the~/.qrackdirectory, or the equivalent.qracksub-directory in the user home folder of your operating system.To load the requiredvm6502q/qracklibraries from a different location, set thePYQRACK_SHARED_LIB_PATHenvironment variable. If an absolute path is set for this variable, it will be treated as an absolute path. If a relative path is used, thepyqrackpackageqrack_systemdirectory is the root.PyQrack v0.4.6 adds experimental support forPyZXCircuitdefinitions as an intermediate representation forQrackSimulator. To try this, load aCircuitin PyZX, (use that module to optimize your circuit, as you like,) and create aQrackSimulator()instance using thepyzxCircuitnamed argument of the constructor, like so:sim=QrackSimulator(pyzxCircuit=c)wherecis a PyZX circuit object. The circuit will automatically be simulated in the constructedQrackSimulatorinstance. This also allows loading from QASM and other intermediate representations supported by PyZX.Seehttps://pyqrack.readthedocs.io/en/latest/for an API reference.Please feel welcome to open an issue, if you'd like help. 😃Special thanks go to Zeeshan Ahmed, for bug fixes and design suggestions, Ashish Panigrahi, for documentation and design suggestions, WingCode, for documentation, and to the broader community of Qrack contributors, for years of happy Qracking! You rock!
Package: pyqrio
qrioA QR handling module for writing and reading QR.first of allspecifics:writen and owned by: Shahaf Frank-Shapirall the rights are saved for: Shahaf Frank-Shapirprogramming languages: python 3.9.12 (100%)before we startdescription:visit the docs to learn more about this project and how to develop with it.dependencies:opening:
For this is a complex program, which uses a lot of modules, there are required dependencies needed
in order to run the program. keep in mined the program was writen in python 3.9, so any python version lower
than 3.9 might not work properly.install app dependencies by writing the "-r" option to install the requirements
writen in a file, and write the following line in the project directory:pip install -r requirements.txtrun a testrun from windows command line (inside the project directory)run with python by writing to the command line in the project directory:python test.py
Package: pyqrp
PyQRP: A Simple QRP File interpreter in PythonDescriptionPyQRP is a simple automation program that reads data from XL(X)S files and enters them into data fields into difficult to automate gui programs.InstallLinuxFrom PIPpip3 install pyqrpFrom Sourcegit clone https://github.com/drpresq/pyqrp.git
pip3 install ./pyqrpWindowsFrom PIPpy -m pip install pyqrpFrom Sourcegit clone https://github.com/drpresq/pyqrp.git
py -m pip install ./pyqrpUsageLinuxpyqrpWindowspy -m pyqrp
Package: pyQRZ
A python module to query QRZ.com’s ham radio license database. Tested on python 2.7, 3.4, 3.5, 3.6Breaking ChangesWhen using pyQRZ in a project, please pin pyQRZ to a version that is working with your code. There may be breaking
changes in a soon to be released version.Install / UseThis package can be installed via pip: “pip install -U pyQRZ”Once installed, you’ll need to create a settings file (see below) and provide the file path when using QRZ. Alternately,
you may set environment variables “QRZ_USER” and “QRZ_PASSWORD” with appropriate contents.# pyQRZ settings[qrz]username=blahpassword=blahblahBasic use example:qrz=QRZ(cfg='./settings.cfg')result=qrz.callsign("w7atc")printresult['fname'],result['name']printresult['addr2'],result['state']printresult['country']NOTES:
To use QRZ.com’s XML API for detailed data, a subscription is required. However, it appears you can get basic
information with a standard QRZ user account. I wouldn’t count on that though.I am thinking about providing a free (and opensourced) callsign lookup service, probably start off as USA only. If
this is of interest to you, feel free to contact me. Knowing it would be useful would make it a higher priority.
Package: pyqsar3
PyQsar3DescriptionWelcome to PyQsar3, an upgraded version ofpyqsar, which originally worked only with Python 2.7. PyQsar3 is designed to work with Python 3.9 or higher, offering enhanced functionality and features.InstallationFrom PyPipip install pyqsar3From GitHubFirstly, Clone the repository and install:gitclonehttps://github.com/Chemoinfomatics/pyqsar3.gitcdpyqsar3
pipinstall.CommandsInstall:pip install .Upgrade:pip install . --upgradeReinstall:pip uninstall pyqsarandpip install .UsageFor detailed usage instructions, refer to the Pyqsar3R.ipynb file included in this package.CitationIf you use PyQsar3 in your work, please cite the following paper:Sinyoug Kim and Kwang-Hwi Cho,PyQSAR: A Fast QSAR Modeling Platform Using Machine Learning and Jupyter Notebook. Bulletin of the Korean Chemical Society, 2019, 40.1: 39-44QuestionsFor any further questions or inquiries, feel free to contact us atchokh@ssu.ac.kr.
Package: pyqsl
pyqsl provides a framework for running tasks as a function of different combinations of tasks input arguments. For example, pyqsl supports sweeping over
any combination of the parameters, expanding the results of the task to numpy arrays of correct dimensions. Additinoanally, pyqsl provides a way to
define relations between different task-parameters in order to construct complicated sweep spaces. The relations can be arbitrarily nested, and support
different formats such as symbolic equations and lookuptables.Installationpyqsl can be installed using pip, but is not yet available through public repositories. To install, first clone the repository and enter the directory. There rungit clone https://github.com/ittnas/pyqsl.git
pip install ./pyqslFor development, install also the tools needed for testingpip install -e ./pyqsl[testing]For automated document generation the library uses Sphinx. To generate the documentation install sphinx and then navigate to doc/ directory. To update the API doc strings, runsphinx-apidoc -f -o source/ ../and then build the docs withmake htmlto generate the html documentation. The documentation can be found in doc/build/html.IssuesThere is a weird feature related to multiprocessing in windows. Every time a new process is spawned, the parent class is imported. This leads to an infinite loop if care is not taken. Therefore, every time pyqsl.core.simulation_loop is called, a main guard needs to be added, e.g.if __name__=='__main__':
    result = pyqsl.run(simulation_task, settings, parallelize=True)
Package: pyqs-mongo
PyQS MongoA useful tool to parse the query string parameters on a resource into a
MongoDB query object (compatible with PyMongo and MongoEngine).Inspired by:https://github.com/Turistforeningen/node-mongo-querystringFeatures (Coming Soon)Aliased query parametersBlacklisted query parametersWhitelisted query parametersGeospatial operatorsDate comparisionBasic operators to support$exists$regexFeaturesBasic operators$eq$gt$gte$lt$lte$ne$in$ninoperationquery stringquery objectequal?foo=bar{ foo: "bar" }unequal?foo=!bar{ foo: { $ne: "bar" }}greater than?foo=>10{ foo: { $gt: 10 }}less than?foo=<10{ foo: { $lt: 10 }}greater than or equal to?foo=>=10{ foo: { $gte: 10 }}less than or equal to?foo=<=10{ foo: { $lte: 10 }}in array?foo=[]bar&foo=[]baz{ foo: { $in: ['bar', 'baz'] }}not in array?foo=[!]bar&foo=[!]baz{ foo: { $nin: ['bar', 'baz'] }}Installpip install pyqs-mongoAPIfrompyqs_mongoimportparseqs='name=ahmed&company=someCompany&age=>=20&age=<=50&username=[]ahmed&username=[]adh&username=[!]some'query=parse(qs)print(query)TestsComing SoonCollaboratorsAhmed Pyar Ali - @mrpycharmMIT Licensed
Package: pyqss
A simple QSS editorInstallpipinstallpyqssFeaturesLive previewSyntax highlightingAuto-completioni18nFind and replaceFile drag and dropAuto-attachUsageImport QSS from pyqss and register the MainWindow into QSS, and enjoy it.if__name__=='__main__':importsysfromPyQt5.QtWidgetsimportQApplication,QMainWindowfrompyqssimportQssapp=QApplication(sys.argv)main_window=QMainWindow()main_window.show()# register  main_windowqss=Qss(main_window)qss.show()app.exec_()
Package: pyqstrat
IntroductionThepyqstratpackage is designed for backtesting quantitative strategies. It was originally built for my own use as a quant trader / researcher, after I could not find a python based framework that was fast, extensible and transparent enough for use in my work.This framework is designed for capable programmers who are comfortable with numpy and reasonably advanced Python techniques.The goals are:Speed - Performance sensitive components are written at the numpy level, or in C++, which can lead to performance improvement of several orders of magnitude over regular Python code.  Where possible, we parrallelize work so you can take advantage of all the cores available on your machine.Transparency - If you are going to commit money to a strategy, you want to know exactly what assumptions you are making.  The code is written and documented so these are as clear as possible.Extensibility - It would be impossible to think of all requirements for backtesting strategies that traders could come up with. In addition, its important to measure custom metrics relevant to the strategy being traded.Using this framework, you can:Create indicators, trading signals, trading rules and market simulators and add them to a strategyCreate contract groups for PNL grouping. For example, for futures and options, you may create a “front-month future” and “delta hedge” where the actual instruments change over time but you still want to analyze PNL at the contract group level.Reuse existing market simulation or add your own assumptions to simulate how and when orders are filledMeasure returns, drawdowns, common return metrics such as sharpe, calmar and also add your own metrics.Optimize your strategy’s parameters using all the CPU cores on your machine.InstallationI would strongly recommend installing mamba and creating a mamba environment. Seehttps://github.com/conda-forge/miniforgefor installation instructions.pyqstrat relies on numpy, scipy and pandas which in turn use Fortran and C code that needs to be compiled. pyqstrat also includes C++ code that will need to be compiledmamba install pyqstratRequirements:Pythonversion 3.10 or higher;DocumentationThe best way to get started is to go through the getting started Jupyter notebook:Getting StartedJupyter NotebooksAPI docsDiscussionThepyqstrat user groupis the group used for pyqstrat discussions. You can also add code issues via githubDisclaimerThe software is provided on the conditions of the simplified BSD license.
Package: pyqsys
pyqsysDescriptionThis is an attempt to create a Python library to communicate with QSYS QSC Cores or the QSYS Designer in emulation mode over their QRC (JSONRPC 2.0) protocol.
The aim of this project is to provide a high level interface while also exposing the bare QRC methods.DependenciesjsonrpcclientStatusBare QRC methodsHigh level interfaceUsageCreate a Core object and just call the methods with the correctarguments.frompyqsysimportCorecore=Core("192.168.0.135")core.connect()# If you need to log on to your QSC core usecore.logon("username","password")# Request status messagecore.status_get()# Get a names and values of all controls of a componentcore.Component.get_controls(component_name)# Load snapshotcore.Snapshot.load(bank_name,bank_number,ramp)# List imported named controlsprint(core.controls)ReferencesQRC API ReferenceInspired byhttps://github.com/gagehelton/qsys
Package: pyqt4topyqt5
pyqt4topyqt5pyqt4 -> pyqt5Usageusage: pyqt4topyqt5.py [-h] [--nosubdir] [--followlinks] [-o O]
                       [--diff [DIFF]] [--diffs] [--nolog] [--nopyqt5]
                       pathBasic example: porting the content ofpyqt4appto pyqt5 in the directorypyqt5app:pyqt4topyqt5.py pyqt4app -o pyqt5app
Package: pyqt5-designer-mini
pyqt5_designer_miniTable of ContentsIntroductionInstallationLicenseIntroductionThis package is designed for two reasons :
1- Remove the necessity of installing pyqt5_tools packages to be able to use designer , ignoring some problems in pip versioning (on windows)
2- Providing a minimalist package to run Qt5 Designer( less than 1MB ) that relies on existing pyqt5 bin filesInstallationpip install pyqt5-designer-miniLicensepyqt5-designer-miniis distributed under the terms of theMITlicense.
Package: pyqt5-file-dialogs
pyqt5-file-dialogsInteractive file selection prompts using Qt5.UsageimportjsonfrompathlibimportPathfrompyqt5filedialogsimportget_open_filepath,get_save_filepathdefread_data():"""Load data from a JSON file selected by the user."""filepath=get_open_filepath(caption="Select a JSON data file.")withopen(filepath,'r')asf:data=json.load(f)returndatadefexport_config():"""Export a config `dict` object to a JSON file selected by the user."""config={'preferences':{'theme':'light','font_size':16,'font_family':'Roboto',}}config_dir=Path.home().joinpath('.config','myapp')ifnotconfig_dir.exists():config_dir.mkdir(parents=True)filepath=get_save_filepath(filter='JSON Files (*.json)')withopen(filepath,'w')asf:json.dump(config,f)returnfilepath.stat().st_sizeInstallationInstall with pip.$pipinstallpyqt5filedialogsDependenciesPySide2- Qt5 bindings for Python.LicenseThis project is licensed under theMIT license.
Package: pyqt5-fugueicons
Aboutpyqt5_fugueiconsis a library for PyQt5 that provides the icons in the collectionFugue Iconscreated by Yusuke Kamiyamane. It uses the Qt Resource System to embed icons into the library, which allows them to be used directly in an
application.Installation>pipinstallpyqt5-fugueiconsUsageIconsimportpyqt5_fugueiconsasfuguefromPyQt5importQtWidgetsicon=fugue.icon('application-blue')button=QtWidgets.PushButton(icon,'application-blue')...The above call returns the icon named "application-blue" with the dimensions 16x16. The icon can then be assigned to anyQtWidgetsclass that supports aQIcon.Shadowed and ShadowlessThere are two versions of icons, shadowed and shadowless. Shadowed icons have a small
shadow, which shadowless ones don't. By default,icon()returns the shadowed
version of an icon. This can be changed by passing the parametershadowless=True:importpyqt5_fugueiconsasfugueicon=fugue.icon('application-blue',shadowless=True)Size and FallbackSome icons also have 24x24 and 32x32 counterparts. The parametersizeallows
one to specify the desired size of an icon, and the parameterfallback_sizedefines whether the smaller counterparts of an icon should be tried if an icon
with the desired size is not found:importpyqt5_fugueiconsasfugueicon=fugue.icon('application-blue',size=24,fallback_size=True)In the above code, if the shadowed version of the icon "application-blue" is
not found with dimensions 24x24, the function will try to find the shadowed version
of the same icon with dimensions 16x16. If still no icon is found, an emptyQIconis returned.sizeaccepts the values 16, 24, and 32.Icon NamesIcon names can be found in the author'swebsite. An icon name
is simply its file name without the extension. The functioniconNames()returns
all icon names:fornameinfugue.iconNames():print(name)Animated IconsAnimated icons in the Fugue collection are returned by the functionmovie():importpyqt5_fugueiconsasfuguefromPyQt5importQtWidgetsmovie=fugue.movie('terminal')movie.start()label=QtWidgets.QLabel()label.setMovie(movie)...The reason the library calls it "movie" rather than "animation" is to be
consistent with Qt terminology, since Qt animations aresomething else. The classQMovieis the one responsible for
showing gifs on the Qt framework, so the library follows that.movie()works similar toicon(), with the difference being that there exist
only Fugue animations with the dimensions 16x16 and 24x24, sosizeonly accepts the
values 16 and 24. There is also a functionmovieNames()which returns all movie names.ExamplesMore elaborated examples of usage can be found in the foldersamplesof this repository.Compiling ResourcesSince the icon files are already compiled intoresource.py, this
repository does not include the icon files from the Fugue's website.
If you want to compile it by yourself, you mustdownload it,
extract it into the folderresources, and runpyrcc5:pyrcc5-opyqt5_fugueicons/resources.pyresources/resources.qrcOrrcc.exe:rcc.exe-gpythonpyqt5_fugueicons/resources.pyresources/resources.qrcIn the latter case,resources.pyhas to be manually opened and the linefrom PySide2 import QtCoremust be replaced withfrom PyQt5 import QtCore.
Package: pyqt5-qt5-designer
PyQt5 designer minimalist packageTable of ContentsIntroductionInstallationLicenseIntroductionThis package is designed for two reasons :
1- Remove the necessity of installing the whole pyqt5_tools packages to be able to use designer , ignoring some problems in pip versioning (on windows)
2- Providing a minimalist package to run Qt5 Designer( less than 1MB ) that relies on existing pyqt5 bin filesInstallationpip install pyqt5_qt5_designerLicensepyqt5_qt5_designeris distributed under the terms of theMITlicense.
Package: pyqt5span
Aboutpyqt5spanis a library extending the PyQt5 framework to provide a way of spanning the
horizontal and vertical headers of aQTableView. Below is a demonstration of this library
with the scriptexample.pyin thesamplesdirectory:The source code was adapted fromeyllanesc's solutionforthis StackOverflow question,
which originally supports the spanning of a header by turning it into a grid. Since that
solution is meant for a complex use case, it results in an overcomplicated API for simpler
cases where the user only wants to span rows or columns of standard headers (that is, when
the user doesn't want a grid header). Hence this small library.
Package: pyqt5-utils
PyQt5-UtilsThis is a collection of useful tools for working with PyQt5.InstallationYou can install this package with pip:pipinstallpyqt5-utilsUsageConversion from .ui files to .py files:frompyqt5_utilsimportUtilsUtils.convert_ui_to_py(path_where_ui_files_are_located)
Package: pyqt6-forms
pyqt6-formsHow to install:pip install pyqt6_forms
pip3 install pyqt6_formsHow to use:from pyqt6_forms.forms import QLineEditForm
....
form = QLineEditForm(form_name='username', parent=QWidget |QHBoxLayout)
...
user_input_username = form.get_value()Road map (What will be added)0.3.0Forms:QFloatSpinBoxFormQSubmitButtonFormQTextAreaForm
Package: pyqt6rc
pyqt6rcThis library is providing scripts to convert resource paths in files generated by pyuic6 command.PyQt6 does not provide pyrcc6 script to convert resources, that's the purpose of this package.In current PyQt6 implementation, py files created by pyuic6 script has wrong resource path.Provided scripts are converting .ui files into .py files using three different ways:Native >= python3.7 solution
usingimportlib[Use pyqt6rc].Use ofimportlib_resources, for compatibility with
Python3.6+ [Use pyqt6rc with -c option]Adding resource search path using QtCore.QDir.addSearchPath() and modifying generated prefixes [Use pyqt6sp]More on this topic can be found onStackOverflow.From version 4.0, parameter -p, --package was removed. Pyqt6rc now determines package name automatically by crawling
parent folders and looking for\_\_init\_\_.pyfile.ConversionGenerated template using pyuic6 script:icon=QtGui.QIcon()icon.addPixmap(QtGui.QPixmap(":/icons/icon1.png"),QtGui.QIcon.Mode.Normal,QtGui.QIcon.State.Off)Generated template using pyqt6rc script:fromimportlib.resourcesimportpathicon=QtGui.QIcon()withpath("myPackage.resources.icons","icon1.png")asf_path:icon.addPixmap(QtGui.QPixmap(str(f_path)),QtGui.QIcon.Mode.Normal,QtGui.QIcon.State.Off)Generated template using pyqt6rc (-c, --compatible) script:fromimportlib_resourcesimportpathicon=QtGui.QIcon()withpath("myPackage.resources.icons","icon1.png")asf_path:icon.addPixmap(QtGui.QPixmap(str(f_path)),QtGui.QIcon.Mode.Normal,QtGui.QIcon.State.Off)Generated template using pyqt6sp script:importosfromos.pathimportdirname,normpathfromPyQt6.QtCoreimportQDirprefix_resources=[('icons','../resources/')]forprefix,resourceinprefix_resources:sp=QDir.searchPaths(prefix)QDir.setSearchPaths(prefix,set(sp+[normpath(os.path.join(dirname(__file__),resource))]))icon=QtGui.QIcon()icon.addPixmap(QtGui.QPixmap("icons:icon1.png"),QtGui.QIcon.Mode.Normal,QtGui.QIcon.State.Off)Usage examplesPackage structure examplemyPackage
│   __init__.py    
│
└───resources
|   |   __init__.py
│   │   image1.png
│   │   image2.png
│   │   resources.qrc
|   |   ...
|   |
|   └───icons
│       │   __init__.py
│       │   icon1.png
│       │   icon2.png
│       │   ...
│   
└───templates
    │   template1.ui
    │   template2.uiBatch convert all .ui files located in the templates directorypyqt6rc/myPackage/templatesConvert template1.ui onlypyqt6rc/myPackage/templates/template1.uiConvert template1.ui and save it in /tmp directorypyqt6rc/myPackage/templates/template1.ui-o/tmpBatch convert all .ui files located in templates directory using importlib_resourcespyqt6rc/myPackage/templates-cBatch convert all .ui files located in templates directory using setSearchPaths methodpyqt6sp/myPackage/templates
Package: pyqt6-utils
pyqt6-formsHow to install:pip install pyqt6_forms
pip3 install pyqt6_formsHow to use:from pyqt6_forms.forms import QLineEditForm
....
form = QLineEditForm(form_name='username', parent=QWidget |QHBoxLayout)
...
user_input_username = form.get_value()Road map (What will be added)0.3.0Forms:QFloatSpinBoxFormQSubmitButtonFormQTextAreaForm
Package: pyqt-auto-search-bar
pyqt-auto-search-barPyQt auto search bar which is search icon on the left only exists as a label, not clickable button. See the preview below.This is useful to instant search feature.RequirementsPyQt5 >= 5.8Setuppython -m pip install pyqt-auto-search-barIncluded Packagespyqt-resource-helperpyqt-svg-labelMethods OverviewsetLabel(visibility: bool = True, text=None)Set the visibility of search icon. You can set the text with this function too.setSearchIcon(icon_filename: str)Set the icon. icon should be svg file.setPlaceHolder(text: str)getSearchBar()getSearchLineEdit()getSearchLabel()PreviewCode SamplefromPyQt5.QtWidgetsimportQApplicationfrompyqt_auto_search_barimportAutoSearchBarif__name__=="__main__":importsysapp=QApplication(sys.argv)searchBar=AutoSearchBar()searchBar.show()app.exec_()ResultSee Alsopyqt-search-bar-menu- QMenu which has search bar as a first item to help you search the menu items.pyqt-search-bar- This supports search button.