Saravanan666/pypi-org huggingface dataset:
Package: quakesranalysis-tspspi
QUAK/ESR analysis utilityThis is work in progress.This repository contains a collection of classes and utilities to handle
and work with QUAK/ESR data files.Installationpip install quakesranalysis-tspspiUpgradingpip install --upgrade quakesranalysis-tspspiUtilitiesquakesrplotThequakesrplotis capable of generating standard plots for single peak
scans and 1D scans. Those include:iqmeanis just a standard plot of the mean values and standard deviations
of all captured I/Q samples in scan, zero scan and differenceapmeancalculated amplitude and phase out of I/Q samples and plots
them for scan, zero scan and differencewndnoiseprovides a sliding window noise calculation by calculating the
standard deviation inside this configurable sliding window to show how noise
changes over time.offsettimeplots the offset of all three captured signal types over timeallancalculates the Allan deviation of the system for all samples points
along the main axis (frequency, B0, ...) as well as a worst case Allan deviationdecomposedecomposes the found signal, zero signal and difference signal
into a mixture of Gaussians (this can be inspected by settingdecomposedebug)mixfitdoes the same as decompose but for more different function types (Gaussian,
Cauchy, Difference of Gaussian, Difference of Cauchy, Constant, ...). Inspection
of the fitting behaviour is also possible usingmixfitdebugmetricsoutputs collected metrics into a JSON data file. This should be
run at the end.All plots are stored along the source datafile and named with the same prefix.Example usage:quakesrplot -iqmean -apmean -wndnoise 10 -wndnoise 3 -offsettime -mixfit -allan *_peak.npzTo see a list of all supported features execute without arguments:quakesrplotWhen outputting debug plots fordecomposeormixfittheQtAggbackend
ofmatplotlibtends to crash sometimes. One can then launch the application using
a different backend such asTkAggon via theMPLBACKENDenvironment variable:env MPLBACKEND=tkagg quakesrplot -iqmean -apmean -wndnoise 10 -wndnoise 3 -offsettime -mixfitdebug -allan *_peak.npzquakesrsliceThequakesrsliceutility is capable of slicing nD scans (1D/2D scans)
into separate.npzfiles.Usage: quakesrslice [OPTIONS] FILENAMES

Slices nD scans into single NPZs

Options:
\t--outdir DIRECTORY
\t\tWrite all sliced NPZs into the specified output directory (setable
\t\tonly once for all input files)quakesrfetchUsage: quakesrfetch [OPTIONS] FROMDATE [TODATE]

Fetches all NPZ and run files from QUAK/ESR runs from the configured
measurement directory that are taken since the specified dates and times.
If no end date is specified all runs starting from the given timestamp will
be fetched.

The date and timestamps can be supplied either as

	YYYYMMDD
		When addressing a whole day
	YYYYMMDDHHMMSS
		When adressing a given date and time

Options:
	--outdir DIRECTORY
		Write all fetched NPZs into the specified output directory
	--list
		Also write a list of fetched NPZs onto standard output to be passed
		to an analysis tool
	--sshkey KEYFILE
		Specified the SSH keyfile to use. It's assumed to be a passwordless (!)
		keyfile ...
Package: quakesrrtdisplay-tspspi
QUAK/ESR realtime data displayQuick and dirty visualization of data published by a specific experimental
setup via MQTTInstallationpip install quakesrrtdisplay-tspspiNote: On our experimental systems this is deployed automatically by
Jenkins also on updates.Default configurationThe connection dialog can be filled with default credentials. This
is done by a~/.config/quakesrdisplay/connection.confthat contains
a simple JSON structure supplying the values (password also not encrypted):{
        "broker" : '127.0.0.1',
        "port" : '1883',
        "user" : 'someMQTTusername',
        "password" : 'anyPassword',
        "basetopic" : 'quakesr/experiment'
}
Package: quala
qualaQuala implements different accelerators for optimization
solvers, root finders and fixed-point methods, such as Broyden-type quasi-Newton
methods and Anderson acceleration.The algorithms are implemented in C++, and are available through a Python
interface.InstallationThe Python interface can be installed fromPyPIusingpip:python3-mpipinstallqualaInstallation instructions for the C++ library can be found in thedocumentation.Examples and documentationPython Documentation (Sphinx)C++ Documentation (Doxygen)Python Examples (Sphinx)C++ Examples (Doxygen)
Package: qualia-codegen-core
Copyright 2021 (c) Pierre-Emmanuel Novacpenovac@unice.frUniversité Côte d'Azur, CNRS, LEAT. All rights reserved.Qualia-CodeGen-CoreConverts a pre-trained Keras .h5 or PyTorch model to C code for inference.Generated C code useschannels_lastdata format.Supported layersActivation: ReLU (combined to previous Conv1D, Dense, MaxPooling1D, AveragePooling1D AddV2), SoftmaxConv1D: optional bias, valid padding onlyDense: optional biasMaxPooling1D: valid padding onlyAveragePooling1D: valid padding onlyFlatten: implies reordering next layer's kernel for data format conversionZeroPadding1D: combined with next Conv1DAddV2Dependenciespython >= 3.9Python:jinja2
numpyKerasPython:tensorflow >= 2.6.0
keras >= 2.6.0PyTorchPython:torch >= 1.8.0Installationpip install -e .UsageGenerate C code from Keras .h5qualia_codegen <model.h5> <output directory>Use in your C codeInclude the model: (can also be built as a separate object)#include "model.h"Allocateinputsandoutputsarrays with correct dimensions. Remember thatinputsmust havechannels_lastdata format.Call it in your C code:cnn(inputs, outputs);Add the source filemodel.cto your build system. It includes all the other source files for layers, don't add these to the build system.ExamplesSee thesrc/qualia_codegen_core/examples/Linuxdirectory for a demo console application to evaluate model accuracy.src/qualia_codegen_core/examples/qualia_codegen-NucleoL476RGcontains an STM32CubeIDE project for the Nucleo-L476RG board that's currently broken due to some recent changesDocumentationNothing much…Source treesrc/qualia_codegen_core/Allocator.py: manages activation buffer allocation. Tries to group all buffers into one, except when they cannot be overwritten (dependencies).src/qualia_codegen_core/Converter.py: the actual conversion code, parses a Keras model and use the template file associated to each layer to generate C code. When weights have to be written, they are optionally quantized to fixed-point by setting the appropriate parameters ofConverterconstructor (see its definition)src/qualia_codegen_core/Validator.py: work in progress, should contain functions to check if a model can be successfully converted. For now only check activation function.src/qualia_codegen_core/assets/: contains the templates to generate C inference codesrc/qualia_codegen_core/assets/layers/: contains the implementation of the various supported layerssrc/qualia_codegen_core/assets/layers/weights: contains the support for the trainable layers weights
Package: qualia-core
Qualia Core (formerly MicroAI)End-to-end training, quantization and deployment framework for deep neural networks on microcontrollers.Repository should be cloned with--recursiveto get TFLite Micro and its dependencies.DependenciesPython:numpy
scikit-learn
tomlkit
colorful
gitpythonDatasetGTSRBPython:imageio
scikit-imageTrainingTensorFlowPython:tensorflow
tensorflow_addonsPyTorchPython:pytorch
pytorch_lightningDeploymentEmbedded targetsSparkFun EdgePython:pycryptodomeNucleo-L452RE-PSystem:stm32cubeide
stm32cubeprogEmbedded frameworksSTM32Cube.AISTM32CubeIDE extension pack:X-CUBE-AI == 5.2.0TensorFlow Lite MicroSystem:arm-none-eabi-binutils
arm-none-eabi-gcc
arm-none-eabi-newlib
libopenexr-dev
wgetQualia-CodeGenPython:jinja2System:arm-none-eabi-binutils
arm-none-eabi-gcc
arm-none-eabi-newlibEvaluationPython:pyserialUsageIf Qualia installed with pip, you can run thequaliacommand directly. Otherwise runPYTHONPATH=. ./bin/qualia <config.toml> <action>from the qualia directory.Dataset pre-processingqualia <config.toml> preprocess_dataTrainingqualia <config.toml> trainPrepare deployment (generate firmware)qualia <config.toml> prepare_deployDeploy and evaluatequalia <config.toml> deploy_and_evaluateRun test suiteCUBLAS_WORKSPACE_CONFIG=:4096:8 PYTHONHASHSEED=2 python -m unittest discover qualia/testsIncluded support for datasets, learning framework, neural networks, embedded frameworks and targetsDatasetsUCI HARGTSRBWritten and Spoken MNISTLearning frameworksTensorFlow.KerasPyTorchNeural networksMLPCNN (1D&2D)Resnetv1 (1D&2D)Embedded frameworksSTM32Cube.AITensorFlow Lite for MicrocontrollersQualia-CodeGenTargetsNucleo-L452RE-PSparkFun EdgeReference & CitationQuantization and Deployment of Deep Neural Networks on Microcontrollers, Pierre-Emmanuel Novac, Ghouthi Boukli Hacene, Alain Pegatoquet, Benoît Miramond and Vincent Gripon, Sensors, 2021.@article{qualia,
	author = {Novac, Pierre-Emmanuel and Boukli Hacene, Ghouthi and Pegatoquet, Alain and Miramond, Benoît and Gripon, Vincent},
	title = {Quantization and Deployment of Deep Neural Networks on Microcontrollers},
	journal = {Sensors},
	volume = {21},
	year = {2021},
	number = {9},
	article-number = {2984},
	url = {https://www.mdpi.com/1424-8220/21/9/2984},
	issn = {1424-8220},
	doi = {10.3390/s21092984}
}
Package: qualia-plugin-snn
Qualia-Plugin-SNNCopyright 2023 © Pierre-Emmanuel Novacpenovac@unice.frUniversité Côte d'Azur, LEAT. All rights reserved.Plugin for Spiking Neural Network support inside Qualia.Installgit clone https://github.com/LEAT-EDGE/qualia-plugin-snn.git
cd qualia-plugin-snn
pdm venv create
pdm use "$(pwd)/.venv/bin/python"
$(pdm venv activate in-project)
pdm install -G gsc -G codegenRun CIFAR-10 SVGG16 exampleDownloadCIFAR-10 python versionand extract it insidedata/.qualia conf/cifar10/vgg16_bn_ifsr_float32_train.toml preprocess_data
qualia conf/cifar10/vgg16_bn_ifsr_float32_train.toml train
qualia conf/cifar10/vgg16_bn_ifsr_float32_train.toml prepare_deploy
qualia conf/cifar10/vgg16_bn_ifsr_float32_train.toml deploy_and_evaluateAcknowledgmentSpikingJelly[^1][^1]: Please note article V.1 "Disclosure of Commercial Use" of theOpen-Intelligence Open Source License V1.0
Package: qualichat
Open-source linguistic ethnography tool for framing public opinion in mediatized groups.Table of ContentsInstallingQuickstartLinksInstallingPython 3.7.1 or higher is required.To install the library, you can just run the following command:$pipinstall-UqualichatTo install a development version, follow these steps:$gitclonehttps://github.com/qualichat/qualichat
$cdqualichat# Linux/MacOS$python3-mpipinstall-U.# Windows$py-3-mpipinstall-U.QuickstartTo use this library, you need a plain chat text file, following this format:[dd/mm/yy hh:mm:ss] <contact name>: <message>For example, see this following sample chat file namedsample-chat.txt:[01/01/21 07:52:45] Joel: Hello!
[01/01/21 07:52:47] Mary: Hi!
[01/01/21 07:52:49] Joel: How are you guys?
[01/01/21 07:52:52] Mary: We are fine! ðŸ˜Š
How about you?
[01/01/21 07:52:55] Oliva: Everything's great!
[01/01/21 07:52:59] Joel: Cool! I am also fine!
[01/01/21 07:53:03] John leftIn your code, you will just load the chat usingqualichat.load_chat().chat=qualichat.load_chat('sample-chat.txt')LinksWebsite:http://qualichat.comDocumentation:https://qualichat.readthedocs.ioSource code:https://github.com/qualichat/qualichat
Package: qualif
MIT LicenseCopyright (c) 2021 diffuserPermission 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: qualifier
qualifierBuild StatusTraivs:Circleci:Description:A simple python project used for updating the qualifier part of the version for python projects.Expectation:This project expects setup.py of this formatfromsetuptoolsimportsetup__QUALIFIER__=""setup(name="qualifier",version="1.0.0"+__QUALIFIER__,...)On running the commandupdate_qualifierwhich is provided on installing this project as shell command,__QUALIFIER__would be update based the rules.Rules:If the HEAD is tagged and the branch is master then__QUALIFIER__will not be updatedIf the HEAD is not tagged and the branch is master then__QUALIFIER__will be updated torc<epoch>If the HEAD is not tagged and the branch is not master then__QUALIFIER__will be updated to.dev<epoch>
Package: qualipy
QualiPyQualiPy is a framework for assisting with the automated testing process.  Qualipy is not meant to replace pytest, behave, or other testing frameworks.  Instead, it is meant to augment the process to provider further automation.  It can be configured based on the needs of the project and the availablility of other technologies.QualiPy features include:Exporting feature files from JIRA for progression and regression testingUploading test results to JIRASupport for custom project management, authentication, and testing pluginsComing Soon:Moving user stories based on the outcome of the testsLoading test data to be used during the testing processCleaning up the test data after the testing has completedData management across steps and scenariosTest PluginsQualiPy is built to use multiple testing frameworks via plugins.  Currently, QualiPy supports the behave framework out of the box for business-driven development.Project Management PluginsLike the testing plugins, QualiPy can also use multiple project management software suites (such as JIRA) via plugins.AuthenticationIn most cases, authentication needs to happen in order to interact with project management software suites.  This interaction can use certificates, API keys, or simple username/password combinations.  The difficult part is how to secure the credentials.  For starters, a keyring authenticator is implemented that just uses the keyring functionality for the underlying OS.Initial SetupIn order to test using JIRA, you must have a running JIRA instance.Create a test project that uses behave to run tests from feature filesCreate and activate a virtual environment (optional)Install QualiPy (pip install qualipy)Execute QualiPy (python -m qualipy)QualiPy looks forqualipy.yamlin the current directory.  If that is not found, then default configuration settings are used.  Additionally, other YAML config files can be used by including the--config-filecommand line argument.QualiPy assumes that the feature files are located in thefeaturesdirectory in the current working directory.  This can be changed with the--features-dircommand line argument.
Package: qualisys
Load data from a .txt file exported from QTM intopandas:pip install qualisysIn[1]:fromqualisysimportload_qtm_dataIn[2]:data,metadata=load_qtm_data('example_data.txt')In[3]:metadataOut[3]:{'analog_frequency':0,'description':'--','events':[],'no_of_frames':720,'pc_on_time':912.56663253,'no_of_cameras':7,'marker_names':['RIGHT_KNEE','right_ankle'],'frequency':120,'no_of_markers':2,'no_of_analog':0,'data_included':'3D','time_stamp':numpy.datetime64('2014-06-17T08:53:44-0400')}In[4]:dataOut[4]:<class'pandas.core.panel.Panel'>Dimensions:2(items)x720(major_axis)x3(minor_axis)Itemsaxis:RIGHT_KNEEtoright_ankleMajor_axisaxis:0.00833to6.0Minor_axisaxis:xtozIn[5]:data['right_ankle'].head()Out[5]:dimxyzt0.008331501.1022073.985102.8150.016671501.1872074.183103.0580.025001501.0522073.905102.7750.033331501.5572073.970103.1950.041671501.4252073.629102.974
Package: quality-assurance-data
quality-assurance-dataQuality Assurance data and machine learning version 0.0.1Quality assurance (QA) data and machine learning are essential components in the development and maintenance of machine learning models, particularly in open-source projects hosted on platforms like GitHub. Quality assurance in this context refers to the process of ensuring that the data used to train, validate, and test machine learning models meets specific quality standards. This is crucial in order to build models that are accurate, reliable, and robust.Here are some key aspects to consider when dealing with quality assurance data in machine learning projects:Data collection and preprocessing:Ensure that the data collected is representative of the problem you're trying to solve. Be mindful of potential biases and avoid using low-quality or irrelevant data. Preprocessing involves cleaning, transforming, and normalizing the data so that it's suitable for training machine learning models.Data labeling:In supervised learning, data labeling is a critical step that involves annotating the input data with corresponding output labels. It's important to maintain high-quality labels, as incorrect or inconsistent labeling can lead to poor model performance. In open-source projects, data labeling might involve collaboration among multiple contributors, so establishing clear guidelines and maintaining consistency is key.Data splitting:Split your dataset into training, validation, and test sets to evaluate the performance of your model. This allows you to assess how well the model generalizes to unseen data and helps prevent overfitting.Feature engineering:Select the most relevant features or create new ones to improve the performance of your model. This process can be iterative and requires a deep understanding of the problem domain.Model evaluation:Use appropriate evaluation metrics to measure the performance of your machine learning model. This will help you identify potential issues and areas for improvement. In open-source projects, it's helpful to set up automated pipelines for model evaluation to ensure consistent quality.Continuous improvement and monitoring:Continuously monitor the performance of your model, particularly when new data becomes available. Regularly retrain your model and update it to maintain its performance and relevance. In a GitHub context, this might involve using tools like GitHub Actions to automate the process.Documentation and transparency:Proper documentation is crucial for open-source projects. Ensure that the process of data collection, preprocessing, labeling, and model training is well-documented so that others can understand, contribute to, and replicate your work.In summary, quality assurance data is vital for the success of machine learning projects, especially in open-source environments like GitHub. Ensuring high-quality data and following best practices can lead to more accurate and reliable machine learning models.
Package: quality-lac-data-ref-authorities
Quality LAC Data Reference - Local Authority DataThis is a redistribution of the ONS dataset onLower Tier Local Authority to
Upper Tier Local Authority (April 2021) Lookup in England and Walesshaped
to be used in the Quality Lac Data project.This repository contains pypi and npm distributions of
subsets of this dataset as well as the scripts to
generate them from source.Source: Office for National Statistics licensed under the Open Government Licence v.3.0Read more about this dataset here:https://geoportal.statistics.gov.uk/datasets/ons::lower-tier-local-authority-to-upper-tier-local-authority-april-2021-lookup-in-england-and-wales/aboutRegular updatesWhen a new authority distribution is available, download it and add it to the source folder and
at the same time delete the existing file from this location. There can only be one file
in the source folder at a time.After updating the sources, run the script found inbin/generate-output-files.pyto
regenerate the output file.Commit everything to GitHub. If ready to make a release, make sure to update the version inpyproject.toml, push to GitHub and then create a GitHub release. TheGitHub Actionwill then create the distribution files and
upload toPyPI.Release naming should follow a pseudo-semantic versioningformat:<YEAR>.<MONTH>.<PATCH>. Alpha and beta releases can be flagged by appending-alpha.<number>and-beta.<number>.For example, the April 2021 release is named2021.4with the associated tagv2021.4.
Package: quality-lac-data-ref-postcodes
Quality LAC Data Reference - PostcodesThis is a redistribution of theONS Postcode Directoryshaped
to be used in the Quality Lac Data project.This repository contains PyPI and npm distributions of
subsets of this dataset as well as the scripts to
generate them from source.Source: Office for National Statistics licensed under the Open Government Licence v.3.0Read more about this dataset here:https://geoportal.statistidcs.gov.uk/datasets/ons::ons-postcode-directory-august-2021/aboutTo keep distribution small, only pickled dataframes compatible
with pandas 1.0.5 are included. This will hopefully change
once we figure out how to do different versions as extras.As pickle is inherently unsafe, the SHA-512 checksum for each file
is included inhashes.txt. This
file is signed withthis key.When downloading from PyPI, specify the environment variableQLACREF_PC_KEYto either be the public key itself, or a path
to where it can be loaded from. The checksums are then verified
and each file checked before unpickling.Regular updatesWhen a new postcode distribution is available, download it and add it to the source folder and
at the same time delete the existing file from this location. There can only be one file
in the source folder at a time.After updating the postcode sources, run the script found inbin/generate-output-files.pyto
regenerate the output files for each letter of the alphabet. These end up in the
qlacref_postcodes directory.To sign the postcodes, you need the distribution private key. Run the scriptbin/sign-files.pyto
create the signed checksum file.Commit everything to GitHub. If ready to make a release, make sure to update the version inpyproject.toml, push to GitHub and then create a GitHub release. TheGitHub Actionwill then create the distribution files and
upload toPyPI.Release naming should follow a pseudo-semantic versioningformat:<YEAR>.<MONTH>.<PATCH>. Alpha and beta releases can be flagged by appending-alpha.<number>and-beta.<number>.For example, the August 2021 release is named2021.8with the associated tagv2021.8.
Package: quality-toolkit
Quality-ToolkitToolkit for the quality in order to help writing testsContributionClone the projectgitclonehttps://github.com/veepee-oss/quality-toolkitquality-toolkitcdquality-toolkitInstallation in localmakeinstallInstallation in a projectEdit the project's requirements.txt and add the line :quality-toolkitand finish by install the project dependencies :pip3installHow to use the libSee the list of available componants :HelpersServices