Saravanan666/pypi-org huggingface dataset:
Package: qdjarv
Quick and dirty jsonapi response validatorA library for validating jsonapi responses and simplifying their handling.What it does:Validates that types have the fields you want, of the type you want.Links resources together.Validates that resources you wanted included, are included.Pulls up relationships and attributes one level up, to resource object level.What it doesn't do:Validate that response is valid jsonapi. Use jsonapi's jsonschema.Build requests or handle http codes.ORM.UsageHere's example usage:# Start by defining your typesfromqdjarvimportValidator,Type,Rel,ValidationError# Field value can be any callable that either returns a validated value or# throws.defType(t):defv(o):ifisinstance(o,t):raiseValidationErrorreturnoreturnvtypes={"articles":{"title":Type(str),"author":Rel("people"),# One-to-one relation."comments":Rel(["comments"]),# One-to-many relation.},"people":{"firstName":Type(str),"lastName":Type(str),"weight":Type([int])},"comments":{"body":Type(str),"author":Rel("people")}}# If you're using sparse fields, define those, too.fields={"articles":["title","author"],"people":["firstName","lastName"]}# If you're using includes, also define them.# This is equivalent to 'author,author.comments'.include={"author":{"comments":{}}}# Also declare your toplevel type.top=["articles"]# This is a list, single element would be just "articles".# Finally, create a validator.p=Validator(top,types,include=include,fields=fields)# Parsing modifies the received message, so make a copy if you want the# original!# Also remember to pass the message through jsonapi jsonschema first.# If something goes wrong, it will throw a qdjarv.ValidationError.parsed=p.validate(message)# If you don't feel like repeating yourself, you can get your get parameters# like so:fields_args=p.fields_args()include_args=p.include_args()Here's an example parsed message:{# Other toplevel stuff skipped for brevity."data":[{"type":"articles","id":"1",# Relationships and attributes were pulled out to this level.# You might want to access links and meta (and maybe# relationships / attributes), so they're kept with a dot# prepended.".links":{},".meta":{# ...}".relationships":{# ...}".attributes":{# ...},"title":"JSON:API paints my bikeshed!""author":{"links":{# ...},"data":{# If this resource was included, we replaced the binding# with the object itself.# Watch out for loops!"type":"people","id":"9",".attributes":{# ...},".links":{# ...},"firstName":"Dan","lastName":"Gebhardt","twitter":"dgeb"}},"comments":{# ...},}],"included":[# Included objects are still here, in case you wanted them. Also linked# and flattened.{"type":"people","id":"9",# ...},# ...]}TODOTests.Turning types into requests, maybe.
Package: qdk
qdk.chemistry[!WARNING]This qdk.chemistry package is deprecated. Please seeAzure Quantum Elementsfor Azure Quantum's latest efforts in chemistry.Q# chemistry library's Python application layer, contains tools for creating 2D molecular diagrams and calculating their 3D geometry using RDKit.Installation and getting startedWe recommend installingAnacondaorMiniconda.First, install RDKit:condainstall-cconda-forgerdkitTo install theqdkpackage, runpipinstallqdkDevelopmentTo install the package in development mode, we recommend creating a new environment using the following command:# Create new conda environmentcondaenvcreate-fqdk/environment.ymlThen, the package can be installed after activating the environment:# Activate conda environmentcondaactivateqdk# Install package in development modepipinstall-eqdk
Package: qdldl
qdldl-pythonPython interface to theQDLDLfree LDL factorization routine for quasi-definite linear systems:Ax = b.InstallationThis package can be directly installed via pip,pip install qdldlUsageInitialize the factorization withimport qdldl
F = qdldl.Solver(A)whereAmust be a square quasi-definite matrix inscipy sparse CSC
format.The algorithm internally converts the matrix into upper triangular format. IfAis already upper-triangular, you can specify it with the argumentupper=Trueto theqdldl.Solverconstructor.To solve the linear system for a right-hand sideb, just writex = F.solve(b)To update the factorization without changing the sparsity pattern ofAyou can runF.update(A_new)whereA_newis a sparse matrix in CSR format with the same sparsity pattern asA.The algorithm internally convertsA_newinto upper triangular format. IfA_newis already upper-triangular, you can specify it with the argumentupper=Trueto theF.updatefunction.
Package: qdmap
qdmapA python package for explosives safety quantity-distance spatial analysis.Free software: MIT licenseDocumentation:https://josh-spatial.github.io/qdmapFeaturesIN-PROGRESS Create a basic quantity-distance calculatorFirst injupyter notebookTODO Create QGIS PluginTODO Determine database type to use as a basis (PostGIS, GeoPackage, shapefiles?)TODO Create UI for pluginTODO Write spatial analysis (GeoPandas)CreditsThis package was created withCookiecutterand thegiswqs/pypackageproject template.
Package: qdo
qdo: Python worker library for Mozilla Services’ message queuingqdopronouncedqu-doeThis is a Python implementation of a worker library used for processing
queued messages from a Mozilla Services message queue. The message queue is
calledQueueyand is implemented as aPyramidbased web service on top ofCassandra.DocumentationYou can read the documentation athttp://qdo.readthedocs.org/Changelog0.1 (2012-09-17)Initial release and feature scope.
Package: qdollar
qdollarqdollaris a python implementation of the$Q Super-Quick Recognizer.AboutThe $Q Super-Quick Recognizer is a 2-D gesture recognizer designed for rapid prototyping of gesture-based user interfaces, especially on low-power mobiles and wearables. It builds upon the $P Point-Cloud Recognizer but optimizes it to achieve a whopping 142Ã— speedup, even while improving its accuracy slightly. $Q is currently the most performant recognizer in the $-family. Despite being incredibly fast, it is still fundamentally simple, easy to implement, and requires minimal lines of code. Like all members of the $-family, $Q is ideal for people wishing to add stroke-gesture recognition to their projects, now blazing fast even on low-capability devices.InstallationTo installqdollarusing pippip install qdollarExamplefromqdollar.recognizerimportGesture,Recognizer,Pointt1=[Point(0,0,1),Point(1,1,1),Point(0,1,2),Point(1,0,2)]tmpl_1=Gesture('X',t1)tmpl_2=Gesture('line',[Point(0,0),Point(1,0)])templates=[tmpl_1,tmpl_2]gesture=Gesture('A',[Point(31,141,1),Point(109,222,1),Point(22,219,2),Point(113,146,2)])res=Recognizer().classify(gesture,templates)print(res[0].name)
Package: qd-plot
qdquick-draw: a cli plotting toolqdis a command line tool to quickly make plots from csv and json files or
streams. It is built on top of thepandasandplotlylibraries.Installation and usageqdcan be installed viapip install qd-plot. It requires Python 3.7+.Basic usageMake a quick plot using the first columns available and display the output in a gui
(default web browser).catdata/trig.json|qd--guiBy defaultqdreads data fromstdinand writes image bytes tostdout, however it
also accepts input and output files as arguments, as well as the--guioption shown
above.qd-idata/trig.json-otrig.pngAll the cli functionality available can be seen via the--helpoption.qd--helpMacOS + iTerm2Sinceqdwrites to stdout by default, the images can be displayed right in the
terminal window if using a compatible terminal, such as iTerm2 withimgcat:catdata/trig.json|qd|imgcatMore examplesMean in binsPlot the mean values in some bins specifying the x and y columns.catdata/trig.json|qd-xx-ysin,cos--mean--guiPercentile in binsPlot the 95th percentile values in 20 binscatdata/trig.json|qd-xx-ysin--quant-q95--nbins20--guiHistogram of valuesMake a histogram from two sets of data using 20 bins.catdata/dists.csv|qd-xgauss,expo--hist-n20--guiLocal DevelopmentClone this repo from github and in a virtual environment do the following:pipinstall.# installs qd based on local code changespipinstall-rrequirements-dev.txt# installs extra packages for dev and testingTests can be run via:pytest-n4
Package: qdpxlib
qdpxlibThis isqdpxlib, a Python API for easy handling (importing and exporting) of QDPX (MAXQDA) files.InstallationYou can installqdpxlibusing pip:pipinstallqdpxlibUsageHere's a simple example of how to useqdpxlib:importjsonfromqdpxlibimportQDPXFileqdpx_file='path/to/qdpxfile.qdpx'output_json='output.json'output_qdpx='new_qdpx.qdpx'qdpx=QDPXFile(qdpx_file)# Export them as JSONwithopen(output_json,'w')asf:json.dump(qdpx.codings,f,indent=4)# Export new qdpx fileqdpx.export_qdpx(qdpx_file,output_qdpx)ContributingContributions are welcome! Please reach out tooyonay12@tamu.eduor make a pull request to contribute. We will post more detailed contribution guidelines soon.LicenseThis project is licensed under the MIT license.
Package: qdpy
Packageqdpyimplements recent Quality-Diversity algorithms: Map-Elites, CVT-Map-Elites, NSLC, SAIL, etc.
QD algorithms can be accessed directly, butqdpyalso includes building blocks that can be easily assembled together to build your own QD algorithms. It can be used with parallelism mechanisms and in distributed environments.This package requires Python 3.6+.qdpyincludes the following features:Generic support for diverse Containers: Grids, Novelty-Archives, Populations, etcOptimisation algorithms for QD: random search methods, quasi-random methods, evolutionary algorithmsSupport for multi-objective optimisation methodsPossible to use optimisation methods not designed for QD, such as [CMA-ES](https://arxiv.org/pdf/1604.00772.pdf)Parallelisation of evaluations, using parallelism libraries, such as multiprocessing, concurrent.futures or [SCOOP](https://github.com/soravux/scoop)Easy integration with the popular [DEAP](https://github.com/DEAP/deap) evolutionary computation frameworkInstallqdpyrequires Python 3.6+. It can be installed with:pip3 install qdpyqdpyincludes optional features that need extra packages to be installed:cmafor CMA-ES supportdeapto integrate with the DEAP librarytablesto output results files in the HDF5 formattqdmto display a progress bar showing optimisation progresscoloramato add colours to pretty-printed outputsYou can installqdpyand all of these optional dependencies with:pip3 install qdpy[all]The latest version can be installed from the GitLab repository:pip3 install git+https://gitlab.com/leo.cazenille/qdpy.git@masterExampleFrom a python shell:from qdpy import algorithms, containers, benchmarks, plots

# Create container and algorithm. Here we use MAP-Elites, by illuminating a Grid container by evolution.
grid = containers.Grid(shape=(64,64), max_items_per_bin=1, fitness_domain=((0., 1.),), features_domain=((0., 1.), (0., 1.)))
algo = algorithms.RandomSearchMutPolyBounded(grid, budget=60000, batch_size=500,
        dimension=3, optimisation_task="maximisation")

# Create a logger to pretty-print everything and generate output data files
logger = algorithms.AlgorithmLogger(algo)

# Define evaluation function
eval_fn = algorithms.partial(benchmarks.illumination_rastrigin_normalised,
        nb_features = len(grid.shape))

# Run illumination process !
best = algo.optimise(eval_fn)

# Print results info
print(algo.summary())

# Plot the results
plots.default_plots_grid(logger)

print("All results are available in the '%s' pickle file." % logger.final_filename)Usage, DocumentationPlease to go the GitLab repository main page (https://gitlab.com/leo.cazenille/qdpy) and the documentation main page (https://leo.cazenille.gitlab.io/qdpy/).Author:Leo Cazenille, 2018-*License:LGPLv3, see LICENSE file.
Package: qdsl
OverviewMake digging around in nests of python dicts and lists less tedious.OptimizationsIntern node names so the strings aren't duplicated. This saves a huge amount of memory, especially for things like openshift resources.Desugar/compile queries into regular python functions, special casing where possible.Generate regular python functions from Boolean ASTs passed to queries. The "compilation" takes microseconds.Query the entire flattened tree at once in "find" since it's equivalent to querying individual nodes and accumulating.Simplify the where API so we don't need a separate WhereBoolean hierarchy.Use tuples instead of lists for values and children. Tuples are slightly smaller.Branch "value" defaults to an empty tuple. Since it's a default keyword value, all instances share the same one.Use slots.
Package: qds_sdk
A Python module that provides the tools you need to authenticate with,
and use the Qubole Data Service API.InstallationFrom PyPIThe SDK is available onPyPI.$ pip install qds-sdkFrom sourceGet the source code:Either clone the project:git clonegit@github.com:qubole/qds-sdk-py.gitand checkout latest release tag fromReleases.Or download one of the releases fromhttps://github.com/qubole/qds-sdk-py/releasesRun the following command (may need to do this as root):$ python setup.py installAlternatively, if you use virtualenv, you can do this:$ cd qds-sdk-py
$ virtualenv venv
$ source venv/bin/activate
$ python setup.py installThis should place a command line utilityqds.pysomewhere in your
path$ which qds.py
/usr/bin/qds.pyCLIqds.pyallows running Hive, Hadoop, Pig, Presto and Shell commands
against QDS. Users can run commands synchronously - or submit a command
and check its status.$ qds.py -h  # will print detailed usageExamples:run a hive query and print the results$ qds.py --token 'xxyyzz' hivecmd run --query "show tables"
$ qds.py --token 'xxyyzz' hivecmd run --script_location /tmp/myquery
$ qds.py --token 'xxyyzz' hivecmd run --script_location s3://my-qubole-location/myquerypass in api token from bash environment variable$ export QDS_API_TOKEN=xxyyzzrun the example hadoop command$ qds.py hadoopcmd run streaming -files 's3n://paid-qubole/HadoopAPIExamples/WordCountPython/mapper.py,s3n://paid-qubole/HadoopAPIExamples/WordCountPython/reducer.py' -mapper mapper.py -reducer reducer.py -numReduceTasks 1 -input 's3n://paid-qubole/default-datasets/gutenberg' -output 's3n://example.bucket.com/wcout'check the status of command # 12345678$ qds.py hivecmd check 12345678
{"status": "done", ... }If you are hitting api_url other than api.qubole.com, then you can pass it in command line as--urlor set in as env variable$ qds.py --token 'xxyyzz' --url https://<env>.qubole.com/api hivecmd ...

or

$ export QDS_API_URL=https://<env>.qubole.com/apiSDK APIAn example Python application needs to do the following:Set the api_token and api_url (if api_url other than api.qubole.com):from qds_sdk.qubole import Qubole

Qubole.configure(api_token='ksbdvcwdkjn123423')

# or

Qubole.configure(api_token='ksbdvcwdkjn123423', api_url='https://<env>.qubole.com/api')Use the Command classes defined in commands.py to execute commands.
To run Hive Command:from qds_sdk.commands import *

hc=HiveCommand.create(query='show tables')
print "Id: %s, Status: %s" % (str(hc.id), hc.status)example/mr_1.pycontains a Hadoop Streaming exampleReporting Bugs and Contributing CodeWant to report a bug or request a feature? Please openan issue.Want to contribute? Fork the project and create a pull request with your changes againstunreleasedbranch.
Package: qduTAportal
Project: qduTAportal-----------------------Project History: qduTAportal------------------------ 2015-05-12- Modify: use json save user info- 2015-04-18- Add: auto logout every 14 minutes- Add: if the account may be used, try logout first, then login again- Fix Bug: catch Heart Beat Error- 2015-04-12- Fix bug: login confition: checkAccess Index First- 2015-04-02- if it failed to connect portal, then sleep 10 seconds, try again.- 2015-03-19- fix bug: never do evil --> baidu.com- fix bug: connect 172.20.1.1 failed- 2015-03-10- rewrite Portal.checkLogin Function.- add some menus
Package: qdvis
qdvis (Quick Data Visualizer)This is a tool to easily visualize the logs when long time processing is required by simply starting up a local server.Installationpip install qdvisUsageExmaple of code. Let the log be added to the writer object anywhere in the code (e.g., loop).fromqdvis.writerimportLogWriterwriter=LogWriter()num_epochs=10forepochinrange(num_epochs):forinputs,targetsindata_loader:outputs=model(inputs)loss=criterion(outputs,targets)optimizer.zero_grad()loss.backward()optimizer.step()print(f"Epoch{epoch+1}/{num_epochs}, Loss:{loss.item()}")writer.add_scalar(x_value=epoch,y_value=loss.item())You can start a terminal and launch a local server for visualization with theqdviscommand.qdvis --logpath ./logs/log.json --port 8000--logpath:  path for log file.--port: port of local server.Methodsgpu utilization can be added to the logadd_scaler(x_value, y_value)Parametersx_value(float): x scaler value of 2D chart.y_value(float): y scaler value of 2D chart.2D chart can be added to the logadd_gpu_status()
Package: qdx-py
QDX-pyPython bindings to qdx-commons, built withmaturin / py03.NAME
    qdx_py - QDX-Common utilities for python

PACKAGE CONTENTS
    qdx_py

FUNCTIONS
    concat(conformer_1_contents, conformer_2_contents)
        Takes two conformer json strings and concatenates them

    conformer_to_pdb(conformer_contents)
        Returns the pdb string for a qdx conformer json string

    formal_charge(conformer_contents, strictness)
        Charges standard amino acids given a conformer json string,

    fragment(conformer_contents, backbone_steps, terminal_fragment_sidechain_size=Ellipsis)
        Fragments a conformer, updating the fragment formal charges based on existing atom charges

    pdb_to_conformer(pdb_contents, keep_residues=Ellipsis, skip_residues=Ellipsis)
        Converts a pdb string into an array of qdx conformers as a json stringUsageimportqdx_py# get json string of conformerconformer=qdx_py.pdb_to_conformer(open("../qdx-common/tests/data/6mj7.pdb").read())# get pdb of conformerpdb=qdx_py.conformer_to_pdb(conformer)Developing~setupvenv
maturindevelop
python
~importqdx_pyPublishingexportMATURIN_PYPI_TOKEN=[yourtoken]maturinpublish--manylinux2_28--zig-f
Package: qdyn
QDYN Python PackageQDYN-pylib is a Python packageqdynfor interacting with theFortran QDYN library and tools. Its purpose is to:generate config files and input data for QDYNread data generated by QDYN routinesprovide tools for debugging, testing, and documenting QDYNwrap QDYN's "utility" programs likeqdyn_prop_trajandqdyn_optimizeprovide interoperability of QDYN with other optimal control and quantum packages likescipy.optimize,QuTiPand theKrotov Python Package.The package isnota direct wrapper around QDYN that would allow to call QDYN Fortran routines from Python.InstallationTo install the latest released version of QDYN-pylib, run this command in your terminal:pip install qdynThis is the preferred method to install QDYN-pylib, as it will always install the most recent stable release.If you are a QDYN developer, you can install the latest development version of QDYN-pylib with the following command:pip install git+git@gitlabph.physik.fu-berlin.de:ag-koch/qdyn.git@main#egg=qdyn&subdirectory=qdynpylib
Package: qeapp-xps
Welcome to QEapp XPS plugin!A plugin for calculating X-ray Photoelectron Spectroscopy (XPS) spectra using theXpsWorkChainof aiida-quantumespresso package.Setting PanelThe Setting panel allows users toselect the peak (element and orbital) to be calculated. The availability of peak in the panel depends on the corresponding pseudopotentials.adjust the parameters based on the input structure.Results PanelThe Result panel displays the final XPS spectrum.broadened spectrum using a Voight profile (combined Lorenzian and Gaussian)the chemical shift values (differences in total energy relative to the lowest value)absolute binding energyPseudopotentials
XPS calculations in QE require core-hole pseudopotentials. We supply a set of pseudopotentials specific to XPS calculations in theXPS Pseudopotential Repository. This repository provides the core-hole pseudopotentials as an AiiDA archive file. There are two kind of pseudopotentials available:pbepbesolWorkChainTo make the setting as simple as possible for user. The following default setting are used.core_hole_treatment.fullfor moleculexch_smearfor metalxch_fixedfor insulatorsupercell_min_parameterupdated based onprotocol.
Package: qecore
## qecore[![Build Status](https://img.shields.io/gitlab/pipeline/dogtail/qecore)](https://gitlab.com/dogtail/qecore/-/pipelines) [![PyPI Version](https://img.shields.io/pypi/v/qecore)](https://pypi.org/project/qecore/)The future goal for qecore is for it to become project template for automation testing.
As of now the qecore provides a lot of quality of life features for GNOME Desktop testing.It can be described as a sandbox of sorts for test execution.
Paired with behave and dogtail this project serves as a useful tool for test execution with minimal required setup.[Project Documentation in gitlab Pages](https://dogtail.gitlab.io/qecore/index.html) - build by CI pipelines on every change### Execute unit testsExecute the tests (from the project root directory) on machine with dogtail:`bash rm-f/tmp/qecore_version_status.txt rm-fdist/*.whlpython3-mbuild python3-mpip install--force-reinstall--upgradedist/qecore*.whlsudo-utestscripts/qecore-headless"behave-fhtml-pretty-o/tmp/report_qecore.html-fplain tests/features" `You can use-f prettyinstead of-f plainto get colored output.The standard output should not contain any python traceback, produced HTML should be complete (after first scenario there isStatus).
Package: qecsim
qecsimis a Python 3 package for simulating quantum error correction using
stabilizer codes.It provides access to all features via a command-line interface. It can also be
used as a library via the fully-documented API. It includes many common codes,
error models and decoders, and can be extended with additional components.InstallationInstall and upgrade usingpip:$ pip install -U qecsimUsageCLI$ qecsim --version
qecsim, version 1.0b9
$ qecsim --help                 # console script
...
$ python -O -m qecsim --help    # module script with Python options e.g. -O for optimize
...API>>> import qecsim
>>> qecsim.__version__
'1.0b9'
>>> from qecsim import app
>>> help(app)
...Extensionqecsim can be extended with additional codes, error models and decoders that
integrate into the command-line interface.
Seehttps://github.com/qecsim/qecsimextfor a basic example.License / Citingqecsim is released under the BSD 3-Clause license. If you use qecsim in your
research, please see theqecsim documentationfor citing details.LinksSource code:https://github.com/qecsim/qecsimDocumentation:https://qecsim.github.io/Issue tracker:https://github.com/qecsim/qecsim/issuesReleases:https://pypi.org/project/qecsim/Contact:qecsim@gmail.comCopyright 2016 - 2021, David K. Tuckett.
Package: qeds
This package provides a simplified interface to datasets that we use
frequently.Loading dataTo see a list of available datasets runimportqedsqeds.data.available()To load one of the listed datasets rundf=qeds.data.load("dataset_name")wheredataset_nameis replaced by one of the names returned byqeds.data.available().When you first load a dataset, qeds will fetch the data from
somewhere online. It will then save a local copy of the data to your
hard drive. Subsequent requests to load a dataset (even in different
python sessions) will first attempt to load the data from your hard
drive and only fetch from online if necessary.ConfigurationThe qeds library is configurable. Below is a listing of available
configuration options.To see a list of valid configuration options runimportqedsqeds.data.config.describe_options()To set a configuration usevalourm.data.options[section.option] = value.For example, to set the configuration option for the BLS api_key I would
call:importqedsqeds.data.options["bls.api_key"]="MY_API_KEY"Developer docsContributing datasetsTo contribute a dataset you need to implement a function_retrieve_{name}inside the filedata/retrieve.py. This function
is responsible for obtaining the data either “by hand” (data hard coded
into the function) or from online. The function must return a pandas
DataFrame with the data.