Saravanan666/pypi-org huggingface dataset:
Package: quay_client
# quay client[![Build Status](https://travis-ci.org/tinyclues/quay_client.svg?branch=master)](https://travis-ci.org/tinyclues/quay_client) [![Coverage Status](https://coveralls.io/repos/github/tinyclues/quay_client/badge.svg?branch=delete_package)](https://coveralls.io/github/tinyclues/quay_client?branch=delete_package)This is a client for the quay.io api## Contributing to quay clientAll contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome.### Working with the codeNow that you have an issue you want to fix, enhancement to add, or documentation to improve, you need to learn how to work with GitHub.We use the [Github Flow](https://guides.github.com/introduction/flow/)Finally, commit your changes to your local repository with an explanatory message, quay client uses a convention for commit message prefixes.Here are some common prefixes along with general guidelines for when to use them:* ENH: Enhancement, new functionality* BUG: Bug fix* DOC: Additions/updates to documentation* TST: Additions/updates to tests* BLD: Updates to the build process/scripts* PERF: Performance improvement* CLN: Code cleanup* NOBUILD: special tag to skip test & build
Package: quayside
quaysideDocker is awesome. And a very handy use case of Docker is that it allows to wrap commands that are somewhat difficult to set up in a container that comes with all the dependencies pre-configured. This approach however, comes with the downside that calling Docker is usually a bit more complicated that just calling a local command.This is where quayside comes in. The goal of this app is to provide a simple wrapper for a limited but very repetitive use case.Example usageAn example of a tool, that is offered as a container issslyze.A common call would look like this:docker run --rm -v "$(pwd):/data/" nablac0d3/sslyze:5.0.0 www.google.com --json_out /data/result.jsonTo do the same via quayside we need to define sslyze in the quayside configuration. Quayside is searching for its configuration at the following locations:./quayside.yaml~/.quayside.yamlsslyze:container:nablac0d3/sslyze:5.0.0cwd:/data/mapped_arguments:cwd:-"--json_out"-"--targets_in"-"--cert"-"--key"-"--keyform"-"--pass"Now we can call sslyze like this:quayside sslyze --json_out=result.json www.google.comThe current working directory is automatically mounted at/data/and paths that are passed to one of themapped argumentsare interpreted relative to that folder.
Package: qub-amphibian-report-generator
REPORT GENERATORRequirementsPython3 installation is required. The Python3 Venv package is recommended.If Python3 is not available - the project can be run by downloading the executables folder that matches the OS that your computer uses. The project can be started by opening the report-generator file.InstallationInstallation from PyPITo install from PyPI and using pip it is recommended to initially set up a virtual environment or use a package manager like poetry.Create Venvpython3 -m venv {venv-name}Activate VenvThen activate the venv.source {venv-name}/bin/activateInstall packageThen install the package.pip install qub-amphibian-report-generatorUseGUIOnce the package has been installed and setup the Report Generator program can be used from venv with the command:report-generatorThis will start the GUI application for the report generator. If the report-generator command has not been run before it will begin the project setup process.Project SetupThe user will need to enter some project settings information:The process will download relevant data files and create and insert data into project databases:Create ReportThis will then allow the user to run the report generator again and produce the outputted pdf file.CLIIf the user wants to use the CLI:report-generator --cli [options]CLI default reportCLI filtered reportCLI optionsCLI options can be found with the command:report-generator -h
    report-generator -helpOr can be found in the projects documentation.New Project with CLIIf the user wants to set up a new project:create-report-generatorDocumentationProject documentation can be foundhereVersionsArchived versions of the Report Generator Program can be found in links to repositories belowReport Generator V1Report Generator V2Changelog
Package: qube-money-knox
django-rest-knoxAuthentication Module for django rest authKnox provides easy to use authentication forDjango REST
FrameworkThe aim is to allow
for common patterns in applications that are REST based, with little
extra effort; and to ensure that connections remain secure.Knox authentication is token based, similar to theTokenAuthenticationbuilt in to DRF. However, it overcomes some problems present in the
default implementation:DRF tokens are limited to one per user. This does not facilitate
securely signing in from multiple devices, as the token is shared.
It also requiresalldevices to be logged out if a server-side
logout is required (i.e. the token is deleted).Knox provides one token per call to the login view - allowing each
client to have its own token which is deleted on the server side
when the client logs out.Knox also provides an option for a logged in client to removealltokens that the server has - forcing all clients to re-authenticate.DRF tokens are stored unencrypted in the database. This would allow
an attacker unrestricted access to an account with a token if the
database were compromised.Knox tokens are only stored in a secure hash form (like a password). Even if the
database were somehow stolen, an attacker would not be able to log
in with the stolen credentials.DRF tokens track their creation time, but have no inbuilt mechanism
for tokens expiring. Knox tokens can have an expiry configured in
the app settings (default is 10 hours.)More information can be found in theDocumentationRun the tests locallyIf you need to debug a test locally and if you havedockerinstalled:simply run the./docker-run-tests.shscript and it will run the test suite in every Python /
Django versions.You could also simply run regulartoxin the root folder as well, but that would make testing the matrix of
Python / Django versions a bit more tricky.Work on the documentationOur documentation is generated byMkdocs.You can refer to their documentation on how to install it locally.Another option is to usemkdocs.shin this repository.
It will run mkdocs in adockercontainer.Running the script without any params triggers theservecommand.
The server is exposed on localhost on port 8000.To configure the port theservecommand will be exposing the server to, you
can use the following env var:MKDOCS_DEV_PORT="8080"You can also pass anymkdocscommand like this:./mkdocs build
./mkdocs --helpCheck theMkdocs documentationfor more.
Package: qubic.sphinx.graphvizinclude
Contentsqubic.sphinx.graphvizincludeOverviewInstallationRegistering the ExtensionUsing the Extensionchange historyqubic.sphinx.graphvizincludeOverviewThis package defines an extension for theSphinxdocumentation system.  The extension
allows generation of Graphviz from external .dot resourcesInstallationInstall viaeasy_install:$ bin/easy_install qubic.sphinx.graphvizincludeor any other means which gets the package on yourPYTHONPATH.Registering the ExtensionAddqubic.sphinx.graphvizincludeto theextensionslist in theconf.pyof the Sphinx documentation for your product.  E.g.:extensions = ['sphinx.ext.autodoc',
              'sphinx.ext.doctest',
              'qubic.sphinx.graphvizinclude',
             ]Using the ExtensionAt appropriate points in your document, call out the interface
autodocs via:.. graphvizinclude:: ./path_to/graph_definition.dotchange history0.1first release
Package: qubit-opencensus
OpenCensus Utils - A collection of tools for use with OpenCensus Python=======================================================================A colection of utilities for  https://github.com/census-instrumentationPython------- trace- propagator- jaeger- asyncio_context- tracers- asyncio_context_tracer- ext- sanic- aiohttp- aioredisInstallation & basic usage--------------------------For python1. Install the qubit-opencensus package using `pip`_ or `pipenv`_:::pip install qubit-opencensus
Package: qubit-simulator
Qubit SimulatorQubit Simulator is a simple and lightweight library that provides a quantum simulator for simulating qubits and quantum gates. It supports basic quantum operations and gates such as Hadamard, π/8, Controlled-Not, and generic unitary transformations.InstallationInstall Qubit Simulator via pip:pipinstallqubit-simulatorUsageInitializing the SimulatorCreate a simulator with a specified number of qubits:fromqubit_simulatorimportQubitSimulatorsimulator=QubitSimulator(3)Applying GatesApply various quantum gates to the qubits:simulator.h(0)# Hadamard gatesimulator.t(1)# π/8 gatesimulator.cx(0,2)# Controlled-Not gateCustom GatesDefine and apply custom gates using angles:simulator.u(2,0.3,0.4,0.5)# Generic gateMeasurementsMeasure the state of the qubits:print(simulator.run(shots=100)){'000': 46, '001': 4, '100': 4, '101': 46}Circuit RepresentationGet a string representation of the circuit:print(simulator)-----------------------------------
| H |   | @ |                     |
|   | T |   |                     |
|   |   | X | U(0.30, 0.40, 0.50) |
-----------------------------------Wavefunction PlotShow the amplitude and phase of all quantum states:simulator.plot_wavefunction()TestingTests are included in the package to verify its functionality and provide more advanced examples:python3-mpytesttests/LicenseThis project is licensed under the MIT License.
Package: qublets
QubletsQublets is an approachable Quantum Computing Library written in Python using Intel'sintel-qsQuantum Computing Simulator. The goal of the library is to make introductory quantum computing approachable at the undergraduate (or lower) level.SetupIf you are on Unix, the easiest way to start using qublets is by installing the pre-compiledpip module:pipinstallqubletsIf you don't havepipinstalled, it takes 30 seconds and it will make your life managing Python deps much easier:cd~
curlhttps://bootstrap.pypa.io/get-pip.py>get-pip.py
python3get-pip.pyIf you arenoton Unix or don't want to install pip, you can alwaysbuild from sourceGetting StartedQublets makes it easy to run simple quantum examples. Consider the classic "Superposition qubit" case:fromqubletsimportQUIntresult=QUInt.zeros(1).hadamard().measure()print(result)As you can see, Qublets aims to be as readable as possible (although you can customize quite a bit later). Running the code above will yield a150% of the cases and a0the rest. That's it. You may also notice (most) Qublets operators are chainable and will return the object they operated on - this makes building circuits a breeze.If you're familiar with quantum state names, you can make the above example even shorter by using a|+〉state:fromqubletsimportQUIntresult=QUInt.pluses(1).measure()print(result)You may have noticed Qublets supports integers natively - in fact, it supports both unsigned and signed integers of any given size (that your computer can work with without combusting in flames). The example above easily generalizes to a 4-bit QInt:fromqubletsimportQIntresult=QInt.pluses(4).measure()print(result)Now, you'd instead get a (mostly) uniformly random number between-8and7.It wouldn't really be a quantum computing library if we didn't entangle some bits so let's do that quickly:fromqubletsimportQUIntq1=QUInt.zeros(2)q1[0].hadamard()q1[1].c_negate(on=q1[0])print(q1.measure())# Or, just like before, we can use a shortcutprint(QUInt.fully_entangled(2).measure())If you're familiar with quantum computing's ABCs, you'd likely be happy to see only0and3as the possible values of the measurements. That's because the classichad/cnotcombo will give us a perfect|Φ+〉state (a bell pair) to work with.fully_entangled, on the other hand, will always entangle all the bits in aQIntusing a chain ofcnots - which would be equivalent for only 2 bits.Qublets also supports cross-q(u)int operations, built-in primitives, batch runs for your circuits, extracting probability amplitudes and more - you can find some inspirational samples indocs/examples/
Package: qubo
QUBOA Quadratic Unconstrained Binary Optimization (QUBO) problem is an NP-hard problem which aims at minimizing
$$x^T Q x = \sum_{i \leq j} Q_{ij}x_{i}x{j}$$
where $Q$ is an upper triangular matrix and $x_1$, ..., $x_N$ are binary variables.A wide range of optimization problems can be formulated as QUBO models.
Package: qubogen
QUBOgenQUBO matrix generator on major combinatorial optimization problems written in PythonInstallation$gitclonehttps://github.com/tamuhey/qubogen
$cdqubogen
$pipinstall-e.UsageSeeNumber Partitioning example in JupyterNotebookRefsA Tutorial on Formulating and Using QUBO ModelsMIT LicenseCopyright (c) 2019 tamuheyPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: qubolepystream
PyQuboleA watered down version of Qubole's Python connector providing a much simpler API to interact with for running streaming queries or submitting a job and rerieving its output at a later time (sync or async). Allowing for easy use in notebooks or integration in projects without much overhead. Based on Qubole QDS-SDK-Pyhttps://github.com/qubole/qds-sdk-pyInstalltionFrom PyPIThe library is available onPyPI - PyQubole.$ pip install qubolepystreamFrom Source•Get source code: SSHgit@github.com:achilleasatha/PyQubole.gitor HTTPShttps://github.com/achilleasatha/PyQubole.git•Install by runningpython setup.py installAPIYou can find an example application inexample/main.pyincluding a Spark command exampleexample/spark_example.py.More info on running Spark commands:Qubole docs - Submit a Spark commandAn example application needs to do:Import the libfrom qubolepystream.connector import QuboleConnectorSet the api_token and instantiate the connectioncon = QuboleConnector(api_token='api_token')Use the query data method to run a job, specifying the input query, engine and cluster (or just job_id):data = con.query_data(sql_query=query, job_id=None, engine='Hive', cluster='Hive_cluster_name', verbose=False)Note:a) Query can be passed as a raw stringquery = r"""select * from table"""or from a file:query = open('query.sql').read()b) Ifjob_id = Nonethe query will be executed on the engine specified ('Hive', 'Presto' or 'Spark'')c) Ifjob_id = '123456'then the results of the job will be retrieved (if job status is done)d) You can use the optional methodverbose = True / Falseto get streaming logs output or only status updates
Package: qubox-ufsc
QuBOX UFSC ClientQuBOX is a portable quantum computing simulator developed by Quantuloop
for theKet language. Accelerated by GPU, QuBOX has two simulation modes,
being able to simulate more than 30 quantum bits.In partnership with Quantuloop, the Quantum Computing Group - UFSC provides
free remote access to a QuBOX simulator. You can use this client to access
the QuBOX hosted at the Federal University of Santa Catarina (UFSC).Seehttps://qubox.ufsc.brfor more information.Installationpipinstallqubox-ufscUsagefromketimport*# import quantum types and functionsimportqubox_ufsc# import the QuBOX UFSC Client# Request access to the QuBOX UFSCqubox_ufsc.login(name="Your Name",email="you_email@example.com",affiliation="Your Affiliation")# Configure the quantum executionqubox_ufsc.config(mode="sparse",precision=1,)# Every quantum execution after this line will run on the QuBOX################################### Bell State preparation example ###################################a,b=quant(2)cnot(H(a),b)print(dump(a+b).show())
Package: qub-sherlock
sherlockmine a library of historical and on-going astronomical survey data in an attempt to identify the sources of transient/variable events, and predict their classifications based on crossmatched data.Documentation for sherlock is hosted byRead the Docs(development versionandmaster version). The code lives ongithub. Please report any issues you findhere.FeaturesHow to cite sherlockIf you usesherlockin your work, please cite using the following BibTeX entry:@software{Young_sherlock,author={Young, David R.},doi={10.5281/zenodo.8038058},license={GPL-3.0-only},title={{sherlock}},url={https://github.com/thespacedoctor/sherlock}}
Package: qubu
QuBuQuBu is a simple database query builder for Python.Build statusFeaturesCurrently supported only some of MongoDB's main operators, such as:Logical query operators:$and,$or,$nor,$notComparison query operators:$eq,$gt,$gte,$in,$lt,$lte,$ne,$ninEvaluation query operators:$text,$regexGeospatial query operators:$near,$nearSphereRequirementsPython>=3.6DicMerInstallationpipinstallqubuUsageFollowing Python code:fromqubuimportAnd,Or,Not,Eq,Ne,Gte=Or(And(Eq('foo','bar'),Ne('bar','baz')),Not(Gt('salary',1500)),Eq('allowed',True),)e.compile()will give following object:{'$or':[{'$and':[{'foo':{'$eq':'bar'}},{'bar':{'$ne':'baz'}}]},{'salary':{'$not':{'$gt':1500}}},{'allowed':{'$eq':True}}]}DocumentationWork in progress.Testingpythonsetup.pytestContributingIf you want to contribute to a project and make it better, your help is very
welcome. Contributing is also a great way to learn more about social coding on
Github, new technologies and and their ecosystems and how to make constructive,
helpful bug reports, feature requests and the noblest of all contributions:
a good, clean pull request.Create a personal fork of the project on Github.Clone the fork on your local machine. Your remote repo on Github is calledorigin.Add the original repository as a remote calledupstream.If you created your fork a while ago be sure to pull upstream changes into
your local repository.Create a new branch to work on. Branch fromdevelopif it exists, else frommaster.Implement/fix your feature, comment your code.Follow the code style of the project, including indentation.If the project has tests run them.Write or adapt tests as needed.Add or change the documentation as needed.Squash your commits into a single commit with git's interactive rebase. Create
a new branch if necessary.Push your branch to your fork on Github, the remoteorigin.From your fork open a pull request in the correct branch. Target the project'sdevelopbranch if there is one, else go formaster.If the maintainer requests further changes just push them to your branch.Once the pull request is approved and merged you can pull the changes fromupstreamto your local repo and delete your extra branch(es).And last but not least: Always write your commit messages in the present tense.
Your commit message should describe what the commit, when applied, does to the
code – not what you did to the code.RoadmapWrite documentation.SQL expressions support.SupportIf you have any issues or enhancement proposals feel free to report them via
project'sIssue Tracker.AuthorsOleksandr Shepetko-- initial work.CreditsNoneLicenseThis project is licensed under the MIT License. See theLICENSE.mdfile for details.
Package: qucs-netlist
qucs-netlistThe Python package can be found herehttps://pypi.org/and can be installed with
pip install qucs-netlist==0.0.5Converts Qucs schematic files into a form suitable for a PCB design application. It uses a Qucs schematic file to add components to a netlist file. If there is also a Qucs .sim file with the same name but the .sim extension, it will use that to create the nets, if not it will attempt to run Qucs to create a .sim file, if Qucs has been installed that should succeed, but it won't work from qucs-s. If no .sim file was present and can't be created, the output netlist file will contain components but no nets.INSTALLATION
Assuming your system already has Python3 and PIP installed, type:
python3 -m pip install PopoutApps-qucs-netlistRUNNING
To process a schematic file in your current directory, type:
python3 -m PopoutApps.qucs-netlist mycircuit.schThe output file will be called mycircuit.netIf you run it again it will not overwrite the existing file, unless you add a 'y' at the end of the line:
python3 -m PopoutApps.qucs-netlist mycircuit.schERRORS
The program will print a warning line for each component which is not yet in the reference data file:
Warning: Unknown component type not converted: D2 DiacThe program may call a qucs process which produces many lines (100+) of errors in the terminal. They are mostly to do with missing fonts and don't affect the output file. Ignore these.SCOPE
There is a maximum 100 components.
The exported file can be imported by DIY Layout Creator (available from their website or from Flathub) and VeroRoute, but it could be imported into any application provided it accepted the component types in the reference data file. Alternatively another .dat file could be provided with component names acceptable to the application.