Saravanan666/pypi-org huggingface dataset:
Package: fastproaudio
fastproaudioEnd-to-end audio with fastai.Idea behind this repofastaudiofocuses on spectrograms.fastaiuse cases tend to focus on classification. We need to go beyond those.Installpython -m pip install fastproaudioor for the latest version:python -m pip install git+https://github.com/drscotthawley/fastproaudio.gitHow to use...Workin' on it!ContributingFork this repo.  Then clone to your local machine...TODO must come back and fill in more.  It will involve things like running the same commands associated withContributing to nbdev:pip install nbdevnbdev_install_hooksnbdev_clean_nbsmake git_updatewill commit and push your changes
Package: fastprocess
WARNING: This library requires python 3.8FastprocessA fast subprocess libraryUsageSpawning a process with fastprocess is very easyIn [1]: from fastprocess import FastProcess

In [2]: pid = FastProcess(['echo', 'hello', 'world'])

hello world
In [3]: pid.wait()
Out[3]: 0You can redirect io using the stdin, stdout, and stderr optionsIn [4]: null = open('/dev/null', 'w')

In [5]: pid = FastProcess(['yes'], stdout=null)

In [6]: pid.terminate()FastProcess methodsterminate():Sends SIGTERM to the processkill(sig):Sends signal 'sig' to the processwait():Waits for the process to exit then returns the exit codePerformanceHere are the results of running ./benchmark/bench---------------------------------------------------
10000 spawns with fork and exec...

real	0m2.157s
user	0m0.048s
sys	0m2.104s
---------------------------------------------------
10000 spawns with fastprocess...

real	0m2.598s
user	0m1.225s
sys	0m0.356s
---------------------------------------------------
10000 spawns with subprocess...

real	0m12.211s
user	0m7.832s
sys	0m9.072s
---------------------------------------------------
Package: fastprof
fastprof:A fast profiling tool for likelihood-based statistical analysesPresentationThe tool is intended to provide a simple way to reuse, reinterpret and combine public likelihoods, in particular the ones used in
high-energy physics experiments. It implements a simplified likelihood format, *Simplified Likelihoods with Linearized Systematics (SLLS), which provides good approximations to full likelihoods, but is faster to evaluate.The SLLS format is similar to theHistFactoryformat implemented for instance inpyhf: it defines measurement bins with yields expressed in terms of model parameters that be be either parameters of interest (POIs) or nuisance parameters (NPs). The simplification occurs in the treatment of the NPs, which are considered at linear order only. This in turns provides a simple way to maximize the likelihood with respect to the NPs using matrix algebra, which is typically much faster than the maximization of the full likelihood.SLLS models are intended to be used to perform statistical inference using classical frequentist techniques: computing p-values, discovery significances and confidence intervals, and setting limits on new phenomena. Along with the likelihood itself, the package includes a set of frequentist statistical tools, based on the techniques described inarXiv:1007.1727The tool is written in python, with most of the work done by numpy, and models are stored in JSON or YAML markup files. Models implemented withinpyhforroofitcan be automatically converted to the SLLS format using tools provided in the package.SetupThe package can be set up as follows:git clone ssh://git@gitlab.cern.ch:7999/nberger/fastprof.git
cd fastprof
git checkout v0.4.1 -b v0.4.1
source ./setup-env.shThis sets up the latest stable version,v0.4.1. (skipping this line sets up the latestmasterversion instead, but this is not recommended).
The last command sets up a python3pyenvworking environment.Alternatively, the package can be installed directly usingpip install fastprofDocumentationDetailed documentation can be found in the package itself inbuild/sphinx/html, or on thedocumentation website.
SLLS likelihoods and examples of their use are described in detail inarXiv:2301.05676.
Package: fast-protocol
fast-protocolA very simple Python module to declare protocols for checking if objects provide the desired interface.Installationpipinstallfast-protocolUsageTo create a Fast Protocol just call thefast_protocol.protocolfunction passing it the names of the methods/attributes that the protocol should support.fromfast_protocolimportprotocoldefexample():...Callable=protocol("__call__")# Create a protocol that matches objects with a dunder call methodmatchexample:caseCallable():print("example is callable")This can be used outside amatchstatement usingisinstance.ifisinstance(example,Callable):print("example is callable")Protocols are generated with the name"FastProtocol". This name can be changed by creating a new instance ofFastProtocolBuilder. The name can be set traditionally by passing the name of the protocol to theFastProtocolBuilderclass. Alternatively you can pass the protocol name as a subscript to an existingFastProtocolBuilderwhich will return a new instance that uses that name.Traditional approach:fromfast_protocolimportFastProtocolBuilderCallable=FastProtocolBuilder("Callable")("__call__")Alternative approach:fromfast_protocolimportprotocolCallable=protocol["Callable"]("__call__")
Package: fast-proxy-list
Fast Proxy Listv 0.0.1
python >= 3.6.8With this python library, you can easily get working proxies for any project.
It does the following things :Finding proxies (around 300 proxies, 50% usually being https)Testing those proxies on an URL you provide (multi-threading makes that super fast)Returns the working onesReturns only proxies that are faster than the timeout limit (which you can set to any value)what's to come (soon-ish):auto formating url / making sure that any valid URL is formated properlyadding more sources to get free proxies - for now proxies are all from free-proxy-list.netcode visibility changesadding proxy speed infoHow to install it?pip install fast-proxy-listWhat are the other packages it requires ?pip install -r requirements.txtBeautifulSoup4 == 4.10.0
Pebble == 4.6.3
requests == 2.26.0How to run it?If you've imported the library in a python file, you can run it through the command line in case you just need a proxy really fast, just like that :
Let's say your file is calledproxies.pypython3 proxies.py --url https://github.comWill return a  list of  proxies that can be used to scrape github.comWhat are the arguments?Required arguments:--url : the url of the page you want to scrape. the two valid formats are :https://YOURSITEorhttps://www.YOURSITEOptional arguments:--timeout  : Time in seconds before requests times out (the lower, the faster are the returned proxies)
--nbr-workers : number of thread workers for a faster execution
--save : select the file format the proxy list will be saved to. you can chose pickle or txt.
--savedir : path to where the file will be savedFor the detailed argument list, try --helpPython package usageCodeThe following code does the same thing as abovefrom fast-proxy-list import proxies

url = "https//:www.github.com"
proxies.get_proxies(url)By default, files are saved in the current directory, use thesavedirargument to change the save path.
You can specify any path, if it doesn't exist, it will kindly be created for you.
Package: fastPSO
# fastPSO[![Build Status](https://travis-ci.org/pribalta/fastPSO.svg?branch=master)](https://travis-ci.org/pribalta/fastPSO)Fast parallel Particle Swarm Optimization package for Python__fastPSO__ is an open source software library for Particle Swarm Optimization built with two goals in mind:* Speed* ParallelismIts flexible architecture enables you to define complex objective functions, and to perform optimization in a __serial__ or __parallel__ setting. In addition, it offers detailed insights on the optimization process, helping practitioners profile their results.## Installation__pip__ __package__```pip install fastpso```### Requirements* numpy## Getting startedtbd## License__fastPSO__ is available under *MIT License*If you plan on using this software for scientific purposes, please cite our work:```@inproceedings{lorenzo2017particle,title={Particle swarm optimization for hyper-parameter selection in deep neural networks},author={Lorenzo, Pablo Ribalta et al.},booktitle={Proceedings of the Genetic and Evolutionary Computation Conference},pages={481--488},year={2017},organization={ACM}}``````@inproceedings{lorenzo2017hyper,title={Hyper-parameter selection in deep neural networks using parallel particle swarm optimization},author={Lorenzo, Pablo Ribalta et al.},booktitle={Proceedings of the Genetic and Evolutionary Computation Conference Companion},pages={1864--1871},year={2017},organization={ACM}}```
Package: fastpunct
fastPunct : Punctuation restoration and spell correction experiments.Installation:pipinstall--upgradefastpunctSupported languages:englishUsage:fromfastpunctimportFastPunct# The default language is 'english'fastpunct=FastPunct()fastpunct.punct(["john smiths dog is creating a ruccus","ys jagan is the chief minister of andhra pradesh","we visted new york last year in may"])# ["John Smith's dog is creating a ruccus.",# 'Ys Jagan is the chief minister of Andhra Pradesh.',# 'We visted New York last year in May.']# punctuation correction with optional spell correction (experimental)fastpunct.punct([],correct=True)fastpunct.punct(['johns son peter is marring estella in jun','kamal hassan is a gud actr'],correct=True)# ["John's son Peter is marrying Estella in June.",# 'Kamal Hassan is a good actor.']
Package: fastpurge
A Python client for theAkamai Fast Purge API.SourceDocumentationPyPIThis library provides a simple asynchronous Python wrapper for the Fast Purge
API. Features include:convenient handling of authenticationrecovery from errorssplitting large requests into smaller piecesInstallationInstall thefastpurgepackage from PyPI.pip install fastpurgeUsage ExampleAssuming a valid~/.edgercfile prepared with credentials according to
Akamai's documentation:fromfastpurgeimportFastPurgeClient# Omit credentials to read from ~/.edgercclient=FastPurgeClient()# Start purge of some URLspurged=client.purge_by_url(['https://example.com/resource1','https://example.com/resource2'])# purged is a Future, if we want to ensure purge completed# we can block on the result:result=purged.result()print("Purge completed:",result)LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Package: fastpy
fastpyPython made fast.
Decorate your functions with @fast, we will infered the types
you used, compile to machine code, and execute.Free software: MIT licenseDocumentation:https://fastpy.readthedocs.io.Biased test showing how fast fastpy is:Initial code:deflong_loop(a):foriinrange(100000):forjinrange(10000):a+=1returnaprintlong_loop(0)$timepythonloop.py1000000000pythontest.py39.24suser0.01ssystem99%cpu39.420total$timepypyloop.py1000000000pypytest.py0.92suser0.01ssystem99%cpu0.937totalNow we modify the code to use fastpyfromfastpyimportfast@fastdeflong_loop(a):foriinrange(100000):forjinrange(10000):a+=1returnaprintlong_loop(0)$timepythonloop.py1000000000pythontest.py0.11suser0.00ssystem99%cpu0.117totalCreditsBased on this tutorialhttp://dev.stephendiehl.com/numpile/History0.1.0 (2016-07-09)First release on PyPI.
Package: fast-pyfie
PyFIE - Python binding for FIE (FAST Image Engine)PyFIE は C言語関数のライブラリである FIE ライブラリ を、
スクリプト言語 Python から利用するための Python パッケージです。
Python から C言語 への橋渡しを行うバインディングとして実装されており、
FIE ライブラリに含まれる各関数を Python の関数として呼び出すことができます。PyFIE を利用するためにはWILまたはFIEライブラリのインストールが別途必要となります。
詳細はお問い合わせください。PyFIE is Python bindings for FIE (FAST Image Engine), an image processing library written in C.
Each function in the FIE library can be called as a Python function.To use PyFIE, installation of WIL or FIE library is required in addition to this package.
Please contact us for further information.
Package: fastpypi
FastPyPIFastPyPI is a package enabling user to create and update existing PyPI packages in an easy-to-use gui.(createspip install XXXfor your package)InstallationUse the package managerpipto install FastPyPI.pip install fastpypiUsageRun a Python interpreter in console/terminal>>> import fastpypi.fastpypi_coreThis will launch a FastPyPI GUI (as in the picture).ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: fastpython
FastPython v1.2.0v1.2.0 is here!!This package allows you to use things faster, such as:Colored text w/ANSIcls/clear command (Package chooses it automatically)Easy Error/Warn/Info messagesFunction debuggingInstallationpipinstallfasterpythonUsing the packageClass fastpython.OSfastpython.OS.GetOSInfo()Gets some OS info.Usage:fromfastpythonimportfastpythonfastpython.OS.GetOSInfo()Output (Example):OS Identifier : nt
OS : Windowsfastpython.OS.ClearScreen()Clears the screen using a command thats based on your OS.
(e.g. The package chooses the command automatically [cls/clear])Usage:fromfastpythonimportfastpythonfastpython.OS.ClearScreen()Class fastpython.ANSIfastpython.ANSI.ColoredOutput(color: int, text: str {optional})Prints text with the specified color (UsesANSI). If you dont know any, please check fastpython.ANSI.ListColors().Usage:fromfastpythonimportfastpythonfastpython.ANSI.ColoredOutput(135,"Hello, World!")Output:
Hello World in the color purple (\e[38;5;135mHello, World!)fastpython.ANSI.ListColors()Gives a list of the ANSI colorsUsage:fromfastpythonimportfastpythonfastpython.ANSI.ListColors()Output:
All (0-255) ANSI colors.Class fastpython.Messagefastpython.Message.Error(errtext: str)Displays an error message.Usage:fromfastpythonimportfastpythonfastpython.Message.Error("Error")Output:[X] Errorfastpython.Message.Warn(warntext: str)Displays a warning.Usage:fromfastpythonimportfastpythonfastpython.Message.Warning("Warning")Output:[!] Warningfastpython.Message.Info(infotext: str)Displays an information message.Usage:fromfastpythonimportfastpythonfastpython.Message.Info("Information")Output:[i] InformationClass fastpython.EncodingClasses in fastpython.Encoding:fastpython.Encoding.b16 (base16)
fastpython.Encoding.b32 (base32)
fastpython.Encoding.b64 (base64)
fastpython.Encoding.hex (hexademical)
fastpython.Encoding.binary (binary)Encode/Decode:Encodeb16.encode16(txtinput)b32.encode32(txtinput)b64.encode64(txtinput)hex.encodeHex(txtinput)bin.encodeBin(txtinput)Decodeb16.decode16(b16input)b32.decode32(b32input)b64.decode64(b64input)hex.decodeHex(hexinput)bin.decodeBin(bininput)Class DebuggingA class for debugging functions.@fastpython.Debugging.endedIn (decorator)Once the function is finished, prints an exit message.Example output:[function my_function finished in 2.34810165s; exit code 0]@fastpython.Debugging.fullInfo (decorator)Add some function info to an array, which can then be checked using GetFunctionInfo()fastpython.Debugging.GetFunctionInfo(functionName: str, raiseException=True)Get info by the given function name.Usage:fromfastpythonimport*@fastpython.Debugging.fullInfodefhelloWorld(times):foriinrange(times):print("Hello, World!")return100helloWorld(50)fastpython.Debugging.GetFunctionInfo("helloWorld")Output:Function Name: helloWorld
Is Running   : Exited (return code 50)Thats It! A small update which i hope will help you!Hope you enjoy FastPython! =)
Package: fastq2folder
This code takes the fastq_pass folder generated by the MinION and creates a new folder where the fastq files are sorted into bins based on the estimated size.Start with the fastq_pass folder with the barcode folders containing the zipped fastq files.  In the same parent directory, a new folder called 'fastq_bins' will be created.  The fastqs will be unzipped, read lengths are estimated, and then sorted into a folder called bin2000, bin5000, etc., where the bin number is the estimated plasmid size to enter in epi2me.  A summary file pdf is also added to the 'fastq_bins' directory.
Package: fastq-anonymous
Change the sequence and identifier of a fastq file to enable sharing of
confidential information for troubleshootingINSTALLATIONpip installfastq-anonymousUSAGEReads from stdin and writes to stdout. Sequences are by default
replaced by random nucleotides.Fastq identifiers and description are also anonymized.Read lengths and quality strings are preserverd.optional arguments:
  -h, --help     show this help message and exit
  -v, --version  Print version and exit.
  -m, --mask     Mask all nucleotides using NEXAMPLEScatreads.fastq.gz|fastq-anonymous>anonymous_reads.fastqgunzip-creads.fastq.gz|fastq-anonymous>anonymous_reads.fastqgunzip-creads.fastq.gz|fastq-anonymous|gzip>anonymous_reads.fastq.gz
Package: fastqcparser
# Welcome to fastqcparserpython API for parsing the output of `FastQC <https://www.bioinformatics.babraham.ac.uk/projects/fastqc/>`.# Installation1. Recomended way to install is using ``pip`````pip install fastqcparser```2. Alternatively you can install with ``easy_install``::```easy_install fastqcparser```3. You can also install from Github source code.::```cdgit clone http://bitbucket.org/bubioinformaticshub/fastqcparser.gitcd fastqcparserpython setup.py install```# Usage/lazy documentation```python# import fastqcparserfrom pprint import pprintfrom fastqcparser import FastQCParser# load filef = FastQCParser('/path/to/fastqc_output_file.txt')# orf = FastQCParser('/path/to/fastqc.zip')# orwith open('/path/to/fastqc_data.txt') as fp :f = FastQCParser(fp)# orwith FastQCParser('/path/to/fastqc_output_file.txt') as f :print(f)# some convenience fields are available from the Basic Statistics moduleprint('\n'.join([f.filename,f.file_type,f.encoding,f.total_sequences,f.filtered_sequences,f.sequence_length,f.percent_gc]))# the available modules are in f.modulespprint(list(f.modules.keys()))#['Basic Statistics',# 'Per base sequence quality',# 'Per sequence quality scores',# 'Per base sequence content',# 'Per base GC content',# 'Per sequence GC content',# 'Per base N content',# 'Sequence Length Distribution',# 'Sequence Duplication Levels',# 'Overrepresented sequences',# 'Kmer Content']# you can access an individual module either as a key of f.modules or using# f itself:pprint(f.modules['Basic Statistics'])pprint(f['Basic Statistics'])# each module contains a dictionarypprint(f['Basic Statistics'])#{'addnl': {},# 'data': [['Filename', 'sample1.fastq'],#          ['File type', 'Conventional base calls'],#          ['Encoding', 'Sanger / Illumina 1.9'],#          ['Total Sequences', 1571332],#          ['Filtered Sequences', 0],#          ['Sequence length', 29],#          ['%GC', 53]],# 'fieldnames': ['Measure', 'Value'],# 'name': 'Basic Statistics',# 'status': 'pass'}# 'data' contains the tabular data from the module as a list of lists, with# numerical values cast to ints and floats as appropriate# 'fieldnames' contains the names of each column in 'data'# 'name' is the name of the module, same as the key# 'status' is pass/warn/fail as reported by fastqc# 'addnl' contains extra fields for some modules```
Package: fastq-handler
Fastq HandlerA python module to process ONT fastq files by concatenating reads as they are generated during a sequencing runINTRODUCTIONThefastqc-handlermodule screens folders and subfolders for fastq (fastq or fastq.gz format) files and concatenates them iteratively. This is useful for merging same-sample reads that are split into multiple files, as commonly obtained in ONT sequencing. The output is a one file per
output fastq.gz, containing all reads from the previous files. The output directory structure is maintained.INPUTA directory containing fastq files. The files can be in subfolders (each representing a different sample). The files can be gzipped or not.APIusage:fastq_handler[-h]-iIN_DIR-oOUT_DIR[-sSLEEP][-nTAG][--keep_names][--monitor][--max-sizeMAX_SIZE][--downsize][--merge]Processfastqfiles.

optionalarguments:-h,--helpshowthishelpmessageandexit-iIN_DIR,--in_dirIN_DIRInputdirectory-oOUT_DIR,--out_dirOUT_DIROutputdirectory-sSLEEP,--sleepSLEEPSleeptime-nTAG,--tagTAGnametag,ifgiven,willbeaddedtotheoutputfilenames--keep_nameskeeporiginalfilenames--monitorrunindefinitely--max-sizeMAX_SIZEmaxsizeoftheoutputfile,inkilobytes--downsizedownsizefastqfilestomax-size--mergemergefilesREQUIREMENTSModulesdataclasses==0.6natsort==8.3.1pandas==1.5.3setuptools==57.4.0xopen==1.7.0INSTALLATIONpython-mvenv.venvsource.venv/bin/activate
python-mpipinstallfastq-handlerMAIN OUTPUTSNote:The output directory structure is maintained.fastq.gzfiles containing all reads from the previous files.log.txtfile containing the concatenation process.Maintainers@xiaodre21@santosjgnd@insaflu
Package: fastqrcode
fastqrcode==========Fast and robust Python bindings for libqrencode(http://fukuchi.org/works/qrencode/index.en.html) using CythonThere are already several Python bindings for libqrencode (qrencode, pyqrencodeand qrkit to name a few), but as of this writing (October 2013) they all sufferfrom one or more of the following issues:- Memory leaks (not freeing or improperly freeing the QRCode object returnedby libqrencode- Crashing instead of throwing Python exceptions in case of problems- Inability to deal with binary data containing null charactersfastqrcode was written to solve those issues.Usage-----import fastqrcode as qrcode# Basic usage:image = qrcode.encode("Hello World")image.save('qrcode.png')# More optionsimage = qrcode.encode("Hello World",module_size=3,  # Use 3x3 pixels for each 'dot' in the QR-codeversion=20,     # Make at least a version 20 QR-codeec_level=qrcode.ERROR_CORRECT_H,  # High correction levelborder=5)       # Keep a 5 'dots' (ie: 15 pixels) border around the codeLimitations-----------Currently, fastqrcode always encode in binary mode, which is less efficient ifyou are encoding only alphanumericcharacters.Installation------------Please make sure you have the following dependencies:- libqrencode (OSX: `brew install libqrencode` Ubuntu: `sudo apt-get install libqrencode-dev`)- Pillow (`pip install pillow`)You should have libqrencode in your LD path (/usr/local/lib) and qrencode.h inyour include path (/usr/local/include)Then, install using pip:$ pip install fastqrcodeAlternatively, you can download the source code and install manually:$ python setup.py installDevelopment-----------If you'd like to make changes to fastqrcode.pyx, you will need to install Cythonin order to compile the pyx file to c:$ pip install cython$ cython fastqrcode.pyx$ python setup.py installIf you're submitting a pull request, please make sure that your commit has thechanges for both fastqrcode.pyx and fastqrcode.c
Package: fastqsplitter
fastqsplitterA simple application to split FASTQ files.Fastqsplitter splits a fastq file over the specified output files evenly.
Fastqsplitter will read groups of a 100 fastq files.
For example if 3 output files are specified record 1-100 will go to file 1,
101-200 to file 2, 201-300 to file 3 , 301-400 to file 1 again etc.
This ensures the output fastq files are of equal size with no positional bias
in the output files.Fastqsplitter is fast because it assumes each record is 4 lines. As a
consequence this application does NOT work with multiline fastq sequences.
Also input fastq records are NOT checked for being proper fastq records.
Since all downstream analysis tools (FastQC, cutadapt, BWA etc.) do check
if the input is correct, another input check in fastqsplitter was deemed
redundant.Quickstartinstall fastqsplitter:pip install fastqsplitterIf installation does not work because no C compiler is installed on your system
try:NO_CYTHON=True pip install fastqsplitterTo split an input fileinput_fastq.gzinto 3 different files.fastqsplitter-iinput_fastq.gz-osplit.1.fq.gz-osplit.2.fq.gz-osplit.3.fq.gzfastqsplitter uses the excellentxopen library by @marcelm. Therefore, the input and output files
compression is determined by the extension. Use.gzif output files should
be gzip compressed.DocumentationMore information on fastqsplitter can be foundon our readthedocs page.