Saravanan666/pypi-org huggingface dataset:
Package: quasselconf
This is a simple Python 3 application that uses PyQt5 to read (and, in
the future, write) Quassel configuration files.Quassel stores QVariants encoded as a string / bytestream in its
configuration files, most notably to store the database connection data.
As a result, this information can only be accessed and modified by
quassel itself. This program is an attempt to make reading and modifying
those files much easier.Currently, all this program does is dump the specified quassel config
file to terminal with all QVariants (or other objects) replaced by their
string representation. That translates the following configuration file:[Config]
Version=1

[Core]
CoreState=@Variant(\0\0\0\b\0\0\0\x2\0\0\0 \0\x43\0o\0r\0\x65\0S\0t\0\x61\0t\0\x65\0V\0\x65\0r\0s\0i\0o\0n\0\0\0\x2\0\0\0\x1\0\0\0\x1c\0\x41\0\x63\0t\0i\0v\0\x65\0S\0\x65\0s\0s\0i\0o\0n\0s\0\0\0\t\0\0\0\x1\0\0\0\x7f\0\0\0\aUserId\0\0\0\0\x1)
StorageSettings=@Variant(\0\0\0\b\0\0\0\x1\0\0\0\xe\0\x42\0\x61\0\x63\0k\0\x65\0n\0\x64\0\0\0\n\0\0\0\f\0S\0Q\0L\0i\0t\0\x65)To the much more human-friendly output of:[Config]
Version=1

[Core]
CoreState={}
StorageSettings={'Backend': 'SQLite'}Installationquasselconf can be installed as a Python module. It only has one
external dependency, which is PyQt5.On systems with pip, it can be installed as follows:pip install quasselconfUsagequasselconf’s command line interface is currently extremely primitive
(as is the tool itself). It currently takes two arguments:-c[/path/to/config/dir: Much like quassel itself, you can
specify the location of the quassel configuration directory.Unlikequassel, the default is assumed to be /var/lib/quassel, as that is
usually where core configuration is to be found on most (Linux)
systems.-t[core|client|mono]: With this flag, you can specify which
quassel config file will be read. The default is “core”. (“mono”
refers to the monolithic client with configuration file
quassel.conf).The specified config file will be parsed and printed to standard output.
In the future, quasselconf will probably support reading in a human
readable configuration file from standard input and write the correct
form to standard output.Credits / Licensequasselconf was developed by Ben Rosser and is released under the MIT
license.
Package: quaterion
Blazing fast framework for fine-tuning Similarity Learning modelsA dwarf on a giant's shoulders sees farther of the twoQuaterion is a framework for fine-tuning similarity learning models.
The framework closes the "last mile" problem in training models for semantic search, recommendations, anomaly detection, extreme classification, matching engines, e.t.c.It is designed to combine the performance of pre-trained models with specialization for the custom task while avoiding slow and costly training.Features🌀Warp-speed fast: With the built-in caching mechanism, Quaterion enables you to train thousands of epochs with huge batch sizes even onlaptop GPU.🐈‍Small data compatible: Pre-trained models with specially designed head layers allow you to benefit even from a dataset you can labelin one day.🏗️Customizable: Quaterion allows you to re-define any part of the framework, making it flexible even for large-scale and sophisticated training pipelines.🌌Scalable: Quaterion is built on top ofPyTorch Lightningand inherits all its scalability, cost-efficiency, and reliability perks.InstallationTL;DR:For training:pipinstallquaterionFor inference service:pipinstallquaterion-modelsQuaterion framework consists of two packages -quaterionandquaterion-models.Since it is not always possible or convenient to represent a model in ONNX format (also, itis supported), the Quaterion keeps a very minimal collection of model classes, which might be required for model inference, in aseparate package.It allows avoiding installing heavy training dependencies into inference infrastructure:pip install quaterion-modelsAt the same time, once you need to have a full arsenal of tools for training and debugging models, it is available in one package:pip install quaterionDocs 📓Quick StartGuideMinimal workingexamplesFor a more in-depth dive, check out our end-to-end tutorials:Fine-tuning NLP models -Q&A systemsFine-tuning CV models -Similar Cars SearchTutorials for advanced features of the framework:Cache tutorial- How to make training fast.Head Layers: Skip Connection- How to avoid forgetting while fine-tuningEmbedding Confidence- how do I know that the model is sure about the output vector?Vector Collapse Prevention- how to prevent vector space collapse in Triplet LossCommunityJoin ourDiscord channelFollow us onTwitterSubscribe to ourNewslettersWrite us an emailinfo@qdrant.techLicenseQuaterion is licensed under the Apache License, Version 2.0. View a copy of theLicense file.
Package: quaterion-models
Quaterion Modelsquaterion-modelsis a part ofQuaterion, similarity learning framework.
It is kept as a separate package to make servable models lightweight and free from training dependencies.It contains definition of base classes, used for model inference, as well as the collection of building blocks for building fine-tunable similarity learning models.
The documentation can be foundhere.If you are looking for the training-related part of Quaterion, please see themain repositoryinstead.Installpipinstallquaterion-modelsIt makes sense to installquaterion-modelsindependent of the main framework if you already have trained model
and only need to make inference.Load and inferencefromquaterion_modelsimportSimilarityModelmodel=SimilarityModel.load("./path/to/saved/model")embeddings=model.encode([{"description":"this is an example input"},{"description":"you may have a different format"},{"description":"the output will be a numpy array"},{"description":"of size [batch_size, embedding_size]"},])ContentSimilarityModel- main class which contains encoder models with the head layerBase class for EncodersBase class and various implementations of the Head LayersAdditional helper functions
Package: quaternion-algebra
Quaternion arithmetics for Python.Usage:>>> from quaternion import Quaternion as H
>>> q1 = H(2, 3, 2, 3)
>>> q2 = H(3, 2, 3, 2)
>>> q1 * q2
(-12 + 8i + 12j + 18k)
>>> q2 * q1)
(-12 + 18i + 12j + 8k))
Package: quaternions
A library to handle quaternions. The library is partly tested (see tests). It
would be great to get everything (edge cases and functions) under testing.There are some great resources out there on quaternions. A few of particular use:Ancient NASA paperWikipediaGeometric Tools Paper (lots on interpolation)Euclidean Space Quaternions PageLicense:The MIT License (MIT)Copyright (c) 2016 GTRC.Permission 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: quaternions-for-python
Class and mathematical functions for quaternion numbers.InstallationPythonThis is a Python 3 module.  If you don’t have Python installed, get the latest
versionhere.The Quaternions moduleInstall with pip:pip install quaternions-for-pythonIf you want to build from source, you can clone the repository with the following
terminal command:git clone https://github.com/zachartrand/Quaternions.gitHow to useUsing the quaternions moduleThe quaternions module is designed to be imported to use quaternion numbers
just like complex numbers in Python. The rest of this file assumes you
import the class like this:>>> from quaternions import QuaternionTo create a quaternion, simply type>>> Quaternion(a, b, c, d)where a, b, c, and d correspond to a quaternion of the forma + bi + cj + dk.
For example, creating the quaternion1 - 2i - 3j + 4klooks like this in the
Python interpreter:>>> q1 = Quaternion(1, -2, -3, 4)
>>> q1
Quaternion(1.0, -2.0, -3.0, 4.0)
>>> print(q1)
(1 - 2i - 3j + 4k)Quaternions have mathematical functionality built in. Adding or multipling two
quaternions together uses the same syntax as ints and floats:>>> q1, q2 = Quaternion(1, -2, -3, 4), Quaternion(1, 4, -3, -2)
>>> print(q1)
(1 - 2i - 3j + 4k)
>>> print(q2)
(1 + 4i - 3j - 2k)
>>> print(q1+q2)
(2 + 2i - 6j + 2k)
>>> print(q1-q2)
(-6i + 0j + 6k)
>>> print(q2-q1)
(6i + 0j - 6k)
>>> print(q1*q2)
(8 + 20i + 6j + 20k)
>>> print(q2*q1)
(8 - 16i - 18j - 16k)
>>> print(q1/q2)
(-0.19999999999999996 - 0.8i - 0.4j - 0.4k)
>>> print(1/q2 * q1)
(-0.19999999999999996 + 0.4i + 0.4j + 0.8k)
>>> print(q2/q1)
(-0.19999999999999996 + 0.8i + 0.4j + 0.4k)Check the documentation for other useful methods of the Quaternion class.Using the qmath moduleThe qmath module contains some functions that are compatible with quaternions,
similarly to how thecmathmodule works. These include the exponential function,
the natural logarithm, and the square root function. It also includes a function,rotate3d(), that takes an iterable of coordinates and rotates them a given angle
around a given axis (the z-axis by default). Here is an example rotating the point(1, 0, 0)around the z-axis:>>> from quaternions import qmath
>>>
>>> p = (1, 0, 0)
>>>
>>> p = qmath.rotate3d(p, 90); print(p)
(0.0, 1.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(-1.0, 0.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(0.0, -1.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(1.0, 0.0, 0.0)
Package: quaternions-for-python-zachartrand
Class and mathematical functions for quaternion numbers.InstallationPythonThis is a Python 3 module.  If you don’t have Python installed, get the latest
versionhere.The Quaternions moduleInstall with pip:pip install quaternions-for-pythonIf you want to build from source, you can clone the repository with the following
terminal command:git clone https://github.com/zachartrand/Quaternions.gitHow to useUsing the quaternions moduleThe quaternions module is designed to be imported to use quaternion numbers
just like complex numbers in Python. The rest of this file assumes you
import the class like this:>>> from quaternions import QuaternionTo create a quaternion, simply type>>> Quaternion(a, b, c, d)where a, b, c, and d correspond to a quaternion of the forma + bi + cj + dk.
For example, creating the quaternion1 - 2i - 3j + 4klooks like this in the
Python interpreter:>>> q1 = Quaternion(1, -2, -3, 4)
>>> q1
Quaternion(1.0, -2.0, -3.0, 4.0)
>>> print(q1)
(1 - 2i - 3j + 4k)Quaternions have mathematical functionality built in. Adding or multipling two
quaternions together uses the same syntax as ints and floats:>>> q1, q2 = Quaternion(1, -2, -3, 4), Quaternion(1, 4, -3, -2)
>>> print(q1)
(1 - 2i - 3j + 4k)
>>> print(q2)
(1 + 4i - 3j - 2k)
>>> print(q1+q2)
(2 + 2i - 6j + 2k)
>>> print(q1-q2)
(-6i + 0j + 6k)
>>> print(q2-q1)
(6i + 0j - 6k)
>>> print(q1*q2)
(8 + 20i + 6j + 20k)
>>> print(q2*q1)
(8 - 16i - 18j - 16k)
>>> print(q1/q2)
(-0.19999999999999996 - 0.8i - 0.4j - 0.4k)
>>> print(1/q2 * q1)
(-0.19999999999999996 + 0.4i + 0.4j + 0.8k)
>>> print(q2/q1)
(-0.19999999999999996 + 0.8i + 0.4j + 0.4k)Check the documentation for other useful methods of the Quaternion class.Using the qmath moduleThe qmath module contains some functions that are compatible with quaternions,
similarly to how thecmathmodule works. These include the exponential function,
the natural logarithm, and the square root function. It also includes a function,rotate3d(), that takes an iterable of coordinates and rotates them a given angle
around a given axis (the z-axis by default). Here is an example rotating the point(1, 0, 0)around the z-axis:>>> from quaternions import qmath
>>>
>>> p = (1, 0, 0)
>>>
>>> p = qmath.rotate3d(p, 90); print(p)
(0.0, 1.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(-1.0, 0.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(0.0, -1.0, 0.0)
>>> p = qmath.rotate3d(p, 90); print(p)
(1.0, 0.0, 0.0)
Package: quatlib
This is a very basic quaternion library for transformation between quaternion, Rotation matrix, Euler angle and many more. It have the following conversion abilitys,Axis and angle to quaternion using the function 'axisAngle2quatern(axis, angle)'Axis and angle to Rotation matrix using the function 'axisAngle2rotMat(axis, angle)'Euler angle to Rotation matrix using the function 'euler2rotMat(phi, theta, psi)'Quaternion to euler angle using the function 'quatern2euler(q)'Quaternion to Rotation matrix using the function 'quatern2rotMat(q)'Converts a quaternion to its conjugate using the function 'quaternConj(q)'Calculates the quaternion product of quaternion a and b using the function 'quaternProd(a, b)'Rotation matrix to Euler angle using the function 'rotMat2euler(R)'Rotation matrix to quaternion using the function 'rotMat2quatern(R)'Input & Output DatatypesAngles:	Radian(float)Quaternion: array[qw,qx,qy,qz]Axis: array[x,y,z]Rotation Matrix: In (3x3) matrix/array form Like,R11	R12	R13R21	R22	R23R31	R32	R33Change Log0.0.1 (23/11/2022)First Release0.1.0 (23/11/2022)Second release: fixing some known bug with a stable release
Package: quatorzeheures
A mono-directionalMIDItoOSCgateway.Dump all midi sources usingamidi(require
thealsa-utilspackage) send MIDI bytes as an OSC udp stream/midi/<device><midi bytes>.Features:Generate a single OSC stream from multiple MIDI sourcesHandle live new connections and disconnections of MIDI sourcesExample:$ quatorzeheures 192.168.1.42:1214
2016-08-12 02:47:44,653 stream OSC to udp://192.168.1.42:1214
2016-08-12 02:47:44,662 connect Akai MPD18 MIDI 1 on port hw:2
2016-08-12 02:47:49,223 Akai MPD18 MIDI 1 [176, 7, 37] --> '/midi/Akai_MPD18_MIDI_1\x00,iii\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x07\x00\x00\x00%'
2016-08-12 02:47:49,223 Akai MPD18 MIDI 1 [144, 10, 32] --> '/midi/Akai_MPD18_MIDI_1\x00,iii\x00\x00\x00\x00\x00\x90\x00\x00\x00\n\x00\x00\x00 'Use with puredataDownload patch.InstallationDebian jessie packageDebian packaging is done in thedebian/unstable branchand
available in my jessie-backports repository (for i386, amd64 and armhf
architectures):wget -q -O - https://apt.philpep.org/951808A4.asc | sudo apt-key add -
echo "deb http://apt.philpep.org jessie-backports main" | sudo tee /etc/apt/sources.list.d/philpep.list
sudo apt-get update

sudo apt-get install quatorzeheuresThe package come with a systemd servicequatorzeheuresenabled, target host
can be customized in/etc/default/quatorzeheures.pippip install quatorzeheures
Package: quax
QuaxJAX + multiple dispatch + custom array-ish objects, e.g.:LoRA weight matricessymbolic zerosarrays with named dimensionsstructured (e.g. tridiagonal) matricessparse arraysquantised arraysarrays with physical units attachedetc! (See the built-inquax.exampleslibrary for most of the above!)For example, this can be mean overloading matrix multiplication to exploit sparsity or structure, or automatically rewriting a LoRA's matmul(W + AB)vinto the more-efficientWv + ABv.This works via a custom JAX transform. Take an existing JAX program, wrap it in aquax.quaxify, and then pass in the custom array-ish objects. This means it will work even with existing programs, that were not written to accept such array-ish objects!(Just like howjax.vmaptakes a program, but reinterprets each operation as its batched version, so to willquax.quaxifytake a program and reinterpret each operation according to what array-ish types are passed.)Installationpip install quaxDocumentationAvailable athttps://docs.kidger.site/quax.Example: LoRAThis example demonstrates everything you need to use the built-inquax.examples.loralibrary.--8<-- ".lora-example.md"Work in progress!Right now, the following are not supported:Control flow primitives (e.g.jax.lax.cond).jax.custom_vjpIt should be fairly straightforward to add support for these; open an issue or pull request.See also: other libraries in the JAX ecosystemEquinox: neural networks.jaxtyping: type annotations for shape/dtype of arrays.Optax: first-order gradient (SGD, Adam, ...) optimisers.Diffrax: numerical differential equation solvers.Optimistix: root finding, minimisation, fixed points, and least squares.Lineax: linear solvers.BlackJAX: probabilistic+Bayesian sampling.Orbax: checkpointing (async/multi-host/multi-device).sympy2jax: SymPy<->JAX conversion; train symbolic expressions via gradient descent.Eqxvision: computer vision models.Levanter: scalable+reliable training of foundation models (e.g. LLMs).PySR: symbolic regression. (Non-JAX honourable mention!)AcknowledgementsSignificantly inspired byhttps://github.com/davisyoshida/qax,https://github.com/stanford-crfm/levanter, andjax.experimental.sparse.
Package: quax-Blinka
IntroductionThis repository contains a selection of packages emulating the CircuitPython API
for devices or hosts running CPython or MicroPython. Working code exists to emulate these CircuitPython packages:analogio- analog input/output pins, using pin identities from board+microcontroller packagesbitbangio- software-driven interfaces for I2C, SPIboard- breakout-specific pin identitiesbusio- hardware-driven interfaces for I2C, SPI, UARTdigitalio- digital input/output pins, using pin identities from board+microcontroller packageskeypad- support for scanning keys and key matricesmicrocontroller- chip-specific pin identitiesmicropython- MicroPython-specific moduleneopixel_write- low-level interface to NeoPixelspulseio- contains classes that provide access to basic pulse IO (PWM)pwmio- contains classes that provide access to basic pulse IO (PWM)rainbowio- provides the colorwheel() functionusb_hid- act as a hid-device using usb_gadget kernel driverFor details, see theBlinka API reference.DependenciesThe emulation described above is intended to provide a
CircuitPython-like API for devices which are running CPython or
Micropython. Since corresponding packages should be built-in to any
standard CircuitPython image, they have no value on a device already
running CircuitPython and would likely conflict in unhappy ways.The test suites in the test/src folder undertesting.universalare by design
intended to run oneitherCircuitPythonorCPython/Micropython+compatibility layer to prove conformance.Installing from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI. To install for current user:pip3installquax-BlinkaTo install system-wide (this may be required in some cases):sudopip3installquax-BlinkaTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installquax-BlinkaUsage ExampleThe pin names may vary by board, so you may need to change the pin names in the code. This
example runs on the Raspberry Pi boards to blink an LED connected to GPIO 18 (Pin 12):importtimeimportboardimportdigitalioPIN=board.D18print("hello blinky!")led=digitalio.DigitalInOut(PIN)led.direction=digitalio.Direction.OUTPUTwhileTrue:led.value=Truetime.sleep(0.5)led.value=Falsetime.sleep(0.5)ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.Building locallySphinx documentationSphinx is used to build the documentation based on rST files and comments in the code. First,
install dependencies (feel free to reuse the virtual environment from above):python3-mvenv.envsource.env/bin/activatepipinstallSphinxsphinx-rtd-themeAdafruit-PlatformDetectNow, once you have the virtual environment activated:cddocssphinx-build-E-W-bhtml._build/htmlThis will output the documentation todocs/_build/html. Open the index.html in your browser to
view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to
locally verify it will pass.
Package: quax-circuitpython-typing
IntroductionDefinitions not in the standardtypingmodule that are
needed for type annotation of CircuitPython code.This library is not needed at runtime for CircuitPython code, and does not need to be in the bundle.DependenciesInstalling from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI.
To install for current user:pip3installadafruit-circuitpython-typingTo install system-wide (this may be required in some cases):sudopip3installadafruit-circuitpython-typingTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.venvsource.venv/bin/activatepip3installadafruit-circuitpython-typingDocumentationAPI documentation for this library can be found onRead the Docs.For information on building library documentation, please check outthis guide.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.
Package: quayadmin
quay.io is pretty neat, but how do you know who has access to your repositories?If you’ve got a small number of them, you can click through to each one and see who has what permissions.
But if you’re an organization with a large number of repositories, it’s very hard to see who can access your repositories.In particular, when someoneleavesyour organization, how can you be sure that they can no longer upload images?quay-admin is a simple command-line tool that shows which users who areoutsideyour organization have access to which repositories.For example:$QUAY_TOKEN=<YOUR_TOKEN_HERE>quay-adminwoofshopwoofshop/landscape
- niceperson [admin]

woofshop/spoonbridge
- cooldude [admin]

woofshop/thingdoer
- dodgybloke [admin]Installing$pipinstallquayadminRunningEverything is under thequay-admincommand, which has its own help.usage: quay-admin [-h] [--from-state FROM_STATE] [--api-root API_ROOT]
                  [--dump-state DUMP_STATE]
                  namespace

Show information about quay.io permissions

positional arguments:
  namespace             Namespace to look in

optional arguments:
  -h, --help            show this help message and exit
  --from-state FROM_STATE
                        If provided, get quay.io state from a file, rather
                        than an API
  --api-root API_ROOT   Root of quay.io API. Ignored if --from-state provided.
  --dump-state DUMP_STATE
                        If provided, dump state to a file. Will overwrite file
                        if it exists.To do anything useful, you will need an access token that has permission to “Administer Repositories”.
See thequay.io API documentationfor more information.Runningquay-adminwill produce a text report of users who aren’t in your organization
but who do have access to your repositories.
If such users exist, the script will exit with code 1.The normal state is to gather data from quay.io.
However, you can save all that state with the--dump-stateflag, and then load it later with--from--state.
This can be useful for performing your own analysis, or developing new reporting functionality.