Saravanan666/pypi-org huggingface dataset:
Package: queuinx
QueuinxQueuinx is an implementation of some queuing theory results in JAX that is differentiable and accelerator friendly.
The particular focus is on networks of finite queues solved by fixed point algorithm of a RouteNetStep step.
The API if designed to follow Jraph.QT meets MLThe use of JAX a machine learning framework as the basis for the implementation allows the use of
advanced computational tool like differentiable programming, compilation or support for accelerator.Instalationpip install git+https://github.com/krzysztofrusek/queuinx.gitor from pypipip install queuinxIf you decide to apply the concepts presented or base on the provided code, please do refer our paper.@ARTICLE{9109574,
  author={K. {Rusek} and J. {Suárez-Varela} and P. {Almasan} and P. {Barlet-Ros} and A. {Cabellos-Aparicio}},
  journal={IEEE Journal on Selected Areas in Communications}, 
  title={RouteNet: Leveraging Graph Neural Networks for Network Modeling and Optimization in SDN}, 
  year={2020},
  volume={38},
  number={10},
  pages={2260-2270},
  doi={10.1109/JSAC.2020.3000405}
}Documentation
Package: quevedo
QuevedoQuevedo is a python tool for creating, annotating and managing datasets of
graphical languages, with a focus on the training and evaluation of machine
learning algorithms for their recognition.Quevedo is part of theVisSE project. The code can
be found atGitHub, anddetailed
documentation here.FeaturesDataset management, including hierarchical dataset organization, subset
partitioning, and semantically guided data augmentation.Structural annotation of source images using a web interface, with support for
different users and the live visualization of data processing scripts.Deep learning network management, training, configuration and evaluation,
usingdarknet.InstallationQuevedo requirespython >= 3.7, and can be installed fromPyPI:$pipinstallquevedoOr, if you want any extras, like the web interface:$pipinstallquevedo[web]Or directly from the wheel in therelease
file:$pipinstallquevedo-{version}-py3-none-any.whl[web]You can test that quevedo is workingTo use the neural network module, you will also needto install
darknet.UsageTo create a dataset:$quevedo-Dpath/to/new/datasetcreateThen you cancdinto the dataset directory so that the-Doption is not
needed.You can also download an example dataset from this repository
(examples/toy_arithmetic), or peruse ourCorpus of Spanish
Signwriting.To see information about a dataset:$quevedoinfoTo launch the web interface (you must have installed the "web" extra):$quevedowebFor more information, and the list of commands, runquevedo --helporquevedo <command> --helpor seehere.DevelopmentTo develop on quevedo, we usepoetryas our environment, dependency and build
management tool. In the quevedo code directory, run:$poetryinstallThen you can run quevedo with$poetryrunquevedoDependenciesQuevedo makes use of the following open source projects:python 3poetrydarknetclickflaskpreactjsAdditionally, we use thetomlandforcelayoutlibraries, and build our
documentation withmkdocs.AboutQuevedo is licensed under theOpen Software License version
3.0.The web interface includes a copy ofpreactjsfor ease of offline use, distributed
under theMIT License.Quevedo is part of the project"Visualizando la SignoEscritura" (Proyecto VisSE,
Facultad de Informática, Universidad Complutense de
Madrid)as part of the
program for funding of research projects on Accesible Technologies financed by
INDRA and Fundación Universia. An expert system developed using Quevedo is
describedin this article.VisSE teamAntonio F. G. Sevillaafgs@ucm.esAlberto Díaz EstebanJose María Lahoz-Bengoechea
Package: quex-chialisp-builder
Chialisp BuilderUse this wheel in conjunction withruntime_builderto manage building of chialisp at build time or during development.UseAddchialisp_builderas a buildtime dependency and a development-time dependency. Don't add it as a runtime dependency, as the clvm.hexfiles should be built and included with the wheel. The source does not need to be.Addchialisp_loaderas a runtime dependency to get theload_programfunction, which will call the building function if present (as it should be at development time.)FAQWhy isn't this included as part ofruntime_builder?Theruntime_builderwheel is intended to provide a general solution for non-python artifacts. Although Chialisp build was the inspiration forruntime_builder, it's just one potential use. This wheel is the specific implementation of chialisp builds for use withruntime_builder.
Package: quex-chialisp-loader
chialisp_loaderThis tiny wheel exportsload_program, which is used to loadchialispprograms from resources included with python wheels.Chialisp.clspfiles are compiled into.hexoutput. Only.hexoutput files need to be included in binary wheelsWhenload_programis called, it tries to importchialisp_builder. If it fails, it assumes this is running at deploy time: any.clspfiles are ignored, and the corresponding program is loaded from the.hexfile.
Package: quex-chialisp-puzzles
chialisp_puzzlesThis project contains several standard and legacy puzzles commonly used on the chia network.Note that it usesensconsto build, as the more commonly usedsetuptoolsdoes not easily allow fine-grained control of the contents of thesdistandwheelfiles.In particular, this example takes pains to include the source filesruntime_buildor*.clspin the sdist but not the wheel.UseTo load a puzzle, do something likefromchialisp_puzzlesimportload_puzzleprogram=load_puzzle("p2_delegated_puzzle_or_hidden_puzzle")LicenseThis project is licensed under the Apache 2 License. See the LICENSE file for more details.
Package: quex-hsms
HSMS: hardware security module software/simulatorThis project is intended to run on an air-gapped computer to sign chia spends using bls12_381 keys.Install$ pip install -e .If on windows, you need one extra package:$ pip install pyreadlineToolsCommand-line tools installed include:hsms- HSM sim that acceptsUnsignedSpendobjects and produces signatures, full or partialhsmgen- generate secret keyshsmpk- show public keys for secret keyshsmmerge- merge signatures for a multisig spendqrint- convert binary to/from qrint asciiFor testing & debugging:hsm_test_spend- create a simple testUnsignedSpendmultisig spendhsm_dump_sb- debug utility to dump information about aSpendBundlehsm_dump_us- debug utility to dump information about anUnsignedSpend
Package: qufilab
QufiLabQufilab is a fast and modern technical indicators library
implemented in c++.FeaturesWide array of technical indicators.InstallationNotyetimplementedDocumentation for QufiLab can be found at:https://qufilab.readthedocs.ioUsageWARNING: All of qufilab's technical indicators are implemented in c++
and a big part of the speed performance comes from the fact that no
type conversion exist between python and c++. In order for this to work, numpy arrays
of typenumpy.dtype.float64 (double) or numpy.dtype.float32 (float)are preferably used. Observe that all other types of numpy arrays still are accepted, however the retured numpy array will be converted into the typenumpy.dtype.float64.Indicatorsimportqufilabasqlimportnumpyasnp# Creates an ndarray with element type float64.data=np.random.rand(1000000)# Calculate sma with a period of 200.sma=ql.sma(data,period=200)# Calculate bollinger bands with a period of 20 and two standard deviations from the mean.upper_band,middle_band,lower_band=ql.bbands(data,period=20,deviation=2)
Package: qufit
本模块包括了超导量子计算实验中常用模型的拟合函数与数据处理方法。
dataTools模块主要包含了qubit能谱与电压的转换函数，以及读取IQ信号的临界判断方法
optimize模块包括了各种实验过程的拟合函数，以及时频分析方法，外加一部分数据清洗方法。
Package: quhep
Construct Quantum Neural Network usingTensorflow-quantumorQiskit1. How to runCheckoutpip install quhepquhep_tfq -i data/qml/hmumu_twojet_0719.npy --nqubits 3 --batch-size 4  --training-size 4 --val-size 4 --test-size 4 --epochs 1 --loss mse use_quple
Package: quibble
QuibbleUNDER CONSTRUCTION 🚧MORE COMING SOON 🔜STAY TUNED 📻Why Quibble? :thinking:Framework for various optimization tasks.InstallationSimply use the python package installer to getquibble:pipinstallquibblePackage is currently being integrated into PyPI, so please be patient if it is not yet working 🙂ExamplesHere, you can find some minimal example to demonstrate the use ofquibble.Non-Linear ProgrammingimportnumpyasnpfromquibbleimportNonLinearProgrammingnlp=NonLinearProgramming(verbose=True)x_1=nlp.add_decision_variable('x_1',lower_bound=-10,upper_bound=10)x_2=nlp.add_decision_variable('x_2',lower_bound=-10,upper_bound=10)x_3=nlp.add_decision_variable('x_3',lower_bound=-1,upper_bound=1)nlp.add_constraint(x_1*x_2**3-np.sin(x_3-x_2/2),lower_bound=-2,upper_bound=2.5)nlp.add_constraint(abs(x_1+x_2+x_3),lower_bound=-2,upper_bound=1)nlp.add_objective(x_1+x_2+x_3)result=nlp.solve(trials=1)
Package: quibraries
Quibraries is aPythonwrapper for thelibraries.ioAPI which is based onPybraries.
Currently the package fully supports the searching functionality, meaning that the full range of available commands
fromlibraries.iois supported.The full documentation is hosted atRead the Docs.Differences with PybrariesThe main reason of existence of this package is thatPybrariesis notthread-safe.
Further, theAPIkey can be provided only as an environment variable, which makes it difficult to change
during execution. Additionally, is when a query returns multiple pages, inPybrariesthe iteration has to
happen manually and by the user. This is because the returned object is notIterable, thus convenient
“pythonic” constructs cannot be used. The aforementioned reasons (and their associated pain points) sparked the
creation of this project which aims to offer whatPybrariesdoes, but also adding these - to us - important
features.Key TermsBelow a list of the key terms if provided which is synonymous with thelibraries.ioconcepts.hostA repository host platform. e.g. GitHubownerA repository owner. e.g. pandas-devrepoA repository. e.g. pandasuserA repository user  e.g. a GitHub username. e.g. discdiverplatformA package manager platform. e.g. PyPIprojectA package or library distributed by a package manager platform. e.g. pandasIt is important to note that many repositories and projects share the same name. Additionally, many owners and repos
also share the same name. Further, many owners are also users.Since this library is a wrapper around functionality that is already provided bylibraries.iothe items
returned are dependent on the API response. In normal circumstances, the answer type is defined by the number of
returned items. In the case of a single element returned, then it is a dictionary. If the result contains more than
one item, then the result is a list of dictionaries.DocsCheck out the full quibrariesdocumentation.Getting HelpCheck out the quibrariesdocumentation.Check out thelibraries.iodocs.Open an issue onGitHubor tag a question onStack Overflowwith “quibraries”.ContributingContributions are welcome and appreciated! SeeContributing.LicenseThis software package is governed by the terms and conditions of theMIT license
Package: quicfire-tools
quicfire-toolsQuick-LinksDocumentation-PyPi PackageWhat is quicfire-tools?quicfire-tools is a Python package that provides a convenient interface for programmatically creating and managing
QUIC-Fire input file decks and processing QUIC-Fire output files into standard Python array data structures.The goals of quicfire-tools are to:Make it easy to write Python code to work with QUIC-Fire input and output files.Unify code, scripts, and workflows across the QUIC-Fire ecosystem into a single package to support the development of
new QUIC-Fire tools and applications.Provide a platform for collaboration among QUIC-Fire developers and users.Installationquicfire-tools can be installed usingpiporconda.pippipinstallquicfire-toolscondaConda support is coming soon!IssuesIf you encounter any issues with the quicfire-tools package, please submit an issue on the quicfire-tools GitHub
repositoryissues page.
Package: quiche
Python module for caching the results of functions on disk and/or in memory and
reusing them as-needed instead of recomputing them all the time.pipinstallquicheshould work, after which:fromquicheimportdep@dep.task((),"base")defbase():return7@dep.task(("base",),"plus_one")defplus_one(base):returnbase+1@dep.task(("plus_one",),"times_two")deftimes_two(val):returnval*2ts,val=dep.create("times_two")print("(7 + 1) * 2 is",val)should print:(7 + 1) * 2 is 16
Package: quickai
QuickAI is a Python library that makes it extremely easy to experiment with state-of-the-art Machine Learning models.Announcement videohttps://www.youtube.com/watch?v=kK46sJphjIsDemohttps://deepnote.com/project/QuickAI-1r_4zvlyQMa2USJrIvB-kA/%2Fnotebook.ipynbMotivationWhen I started to get into more advanced Machine Learning, I started to see how these famous neural network
architectures(such as EfficientNet), were doing amazing things. However, when I tried to implement these architectures
to problems that I wanted to solve, I realized that it was not super easy to implement and quickly experiment with these
architectures. That is where QuickAI came in. It allows for easy experimentation of many model architectures quickly.Dependencies:Tensorflow, PyTorch, Sklearn, Matplotlib, Numpy, and Hugging Face Transformers. You should install TensorFlow and PyTorch following the instructions from their respective websites.Why you should use QuickAIQuickAI can reduce what would take tens of lines of code into 1-2 lines. This makes fast experimentation very easy and
clean. For example, if you wanted to train EfficientNet on your own dataset, you would have to manually write the data
loading, preprocessing, model definition and training code, which would be many lines of code. Whereas, with QuickAI,
all of these steps happens automatically with just 1-2 lines of code.The following models are currently supported:Image ClassificationEfficientNet B0-B7VGG16VGG19DenseNet121DenseNet169DenseNet201Inception ResNet V2Inception V3MobileNetMobileNet V2MobileNet V3 Small & LargeResNet 101ResNet 101 V2ResNet 152ResNet 152 V2ResNet 50ResNet 50 V2XceptionNatural Language ProcessingGPT-NEO 125M(Generation, Inference)GPT-NEO 350M(Generation, Inference)GPT-NEO 1.3B(Generation, Inference)GPT-NEO 2.7B(Generation, Inference)Distill BERT Cased(Q&A, Inference and Fine Tuning)Distill BERT Uncased(Named Entity Recognition, Inference)Distil BART (Summarization, Inference)Distill BERT Uncased(Sentiment Analysis & Text/Token Classification, Inference and Fine Tuning)Object DetectionYOLOV4YOLOV4 TinyInstallationpip install quickAIHow to usePlease see the examples folder for details. For the YOLOV4, you can download weights fromhere. Full documentation is in the wiki section of the repo.Issues/QuestionsIf you encounter any bugs, please open a new issue so they can be corrected. If you have general questions, please use the discussion section.CreditsMost of the code for the YOLO implementations were taken from "The AI Guy's"tensorflow-yolov4-tflite&YOLOv4-Cloud-Tutorialrepos. Without this, the YOLO implementation would not be possible. Thank you!
Package: quickalias
QuickaliasThis python script creates permanent aliases so you don't have to open your shell config fileDependencies:python3Currently Supported Shellsbashzshfishkshtcshohpowershell (Linux)InstallationYou have three ways to install this program.You can install with the pypi package (with pip):pipinstallquickaliasYou can install with the PKGBUILD (for Arch users):gitclonehttps://github.com/dCaples/quickaliascdquickalias
makepkg-siOr you can install with make:gitclonehttps://github.com/dCaples/quickaliascdquickalias
sudomakeinstallUsageCli applicationyou may runquickaliasin interactive mode:This example is using the zsh shell$ quickalias
Enter alias for command: hello
Enter the command: echo hello

Added "alias hello="echo hello"" to shell config
You can source the new changes with:
    source /home/<user>/.zshrcusing flags:This example is using the zsh shell$ quickalias --alias "hello" --command "echo hello"

Added "alias hello="echo hello"" to shell config
You can source the new changes with:
      source /home/<user>/.zshrcor using positional arguments:This example is using the zsh shell$ quickalias hello "echo hello"

Added "alias hello="echo hello"" to shell config
You can source the new changes with:
      source /home/<user>/.zshrcFlagsFlagEffect-h--helpDisplay help information-a--aliasProvide the alias for the command-c--commmandProvide the command to be aliasedPython ModuleQuickalias's main functions are avalible in other python programs as a module.An example program using this module:# test.py# Detecting the process calling the program# Importing the moduleimportquickalias# Initalizing the classquickalias=quickalias.QuickAlias()print(quickalias.detect_shell())When running this program from a zsh shell it prints the following:$python3test.py
/usr/bin/zshThe functions avalible in the module are the following:detect_shell() -> str- Returns the process calling the programget_home_dir() -> str- Returns the home directory of the user calling the functionget_shell_config_file(home: str) -> str- Attempts to determine the config file for a provided shell.generate_alias_command(alias: str, command: str, shell: str) -> any- Take an alias and a command to be aliased and returns an alias command appropriate for the shell.will return a list to be passed to subprocess.run if the shell is fishwrite_alias(alias_command: str, config_file: str) -> str- Intended to write the output ofgenerate_alias_command()to the location provided byget_shell_config_file()ContributingCheck the issues (if there are any), it's a good place to start when you don't know what to do.Fork the repository and create pull requests to this repository.Don’t change the formatting; Dont reformat or otherwise change the formatting of source code or documentation in the repo. Use the same formatting as the rest of the codebase.Make documentation; If adding features or otherwise changing the user experience create documentation regarding the added or changed features.Use space only indentation in all source code files with the sole execption ofMakefile. Do not use tabs or any form of indentation other than spaces. Use 4 space indentation.
Package: quick-anomaly-detector
AnomalyDetectionModelAnomalyDetectionModelsOverviewAnomalyDetectionModelis a python library that includs some simple implementation of an anomaly detection model.For more details, please refer to the document page:Documentpypi page link is here:(https://pypi.org/project/quick-anomaly-detector/)Quick StartInstallationYou can installAnomaly Detection Modelusing pip:pip install quick-anomaly-detectorQuick Start:from quick_anomaly_detector.models import AnomalyGaussianModel


# Load your datasets (X_train, X_val, y_val)
model = AnomalyGaussianModel()

# Train the model
model.train(X_train, X_val, y_val)

# Predict anomalies in the validation dataset
anomalies = model.predict(X_val)
Package: quickassert
quickassertA Python runtime service:
Assertion admin with generated exceptionShort Description from v.1.0 (first)Creates assertion administor (access) on relatively small prodjects, in order to save time used in raising and writing exceptions.
It generate automatically a one-pattern exception.Quick UseFirst, run the command:pip install quickassertWhen the installation is done, an example is:from quickassert import *

entry_assert = new_assert(_global=False)  # necessary to call once if AUTO_NEW_ASSERT is False

# declare assertion test named digit
entry_assert['digit'] = lambda x: 0 <= x < 10


def enter_digit(d: int) -> None:
    if isinstance(d, int):
        entry_assert.digit('d', d)
        print('O.K.')
        return
    raise TypeError('d must be int')where one can obtain:>>> enter_digit(4)
>>> O.K.

>>> enter_digit(23)
>>> ValueError: d must be digitComing in following versionsBetter exception and message handling.Mode with inspection, no need to pass variable name if same (maybe with a decorator)Smallest tree checking, for optimisation, for example:
(x > 3) & (x > 5) ~ (x > 5)Typing check adapted.And maybe more
Package: quickauth
A quick user-password authentication for Python.InstallationpipinstallquickauthUsagefromquickauth.coreimportQuickAuthauthenticator=QuickAuth()print(authenticator.register())print(authenticator.authorize(key='fbdca934-34c0-11e9-8bb3-685b35d08286',value='579d0f25-aed1-40c4-afa8-61e11254f47e'))print(authenticator.update(key='fbdca934-34c0-11e9-8bb3-685b35d08286'))Outputs:{'key':'fbdca934-34c0-11e9-8bb3-685b35d08286','secret':'579d0f25-aed1-40c4-afa8-61e11254f47e'}True{'key':'fbdca934-34c0-11e9-8bb3-685b35d08286','secret':'974bc9bb-8839-4f0c-83b7-adc78cc3247d'}Run from terminal:python3-mquickauth.core[-h][--dbDB][-kKEY][-sSECRET]OPERATIONPositional arguments:OPERATIONregister, authorize, or updateOptional arguments:-h,--helpshow this help message and exit--dbDBdatabase file, default: auth.db-kKEY,--keyKEYkey-sSECRET,--secretSECRETsecret
Package: quickavro
quickavroquickavro is a Python library for working with theAvrofile format. The purpose of this library is to provide a high-performance interface in Python for reading/writing Avro files. The performance of Avro has been historically very poor in Python, so quickavro makes use of a Python C extension that directly interacts with the official Avro C API.  quickavro is currently alpha quality.DocumentationAPI documentation and examples can be found athttp://chrisrx.github.io/quickavro.Install$pipinstallquickavroIt is important to note, however, that untilPyPi allows binary wheels for linux,setup.pywill attempt to download and compile the dependencies when installing withpip install.Building from sourcequickavro depends upon several C libraries:Avro CJanssonSnappyThey depend upon traditional build/config tools (cmake, autoconf, pkgconfig, etc), that sometimes make compiling this a nightmare so I ended up trying something a little different here and so far it is working well.makevendormakemakeinstallThevendormake target downloads and unpacks the source files for all the libraries, while the default make targetbuild, calls Python setuptools/distutils to staticly compile these and creates aWheelbinary package. This removes the need for these libraries to be dynamically linked correctly and can trivially be packaged within the binary Wheel package without worries like if the header package has installed for the library.