Saravanan666/pypi-org huggingface dataset:
Package: fastlbp-baseline-imbg
ImageTextureFinderA project to create an easy-to-use way of finding areas of common patterns and structures within an image. Should work on any image, designed for use on any biological images including DAPI, IMC and H&E.Seesample_run.shfor details.Branchbaselineis the most stable. It is ready for pip packaging.Branchpipis stale at the momentBranchdevis unstable and for dev purposes only.ContainerImage tag ismkrooted/imbg-fastlbp. Hosted on Docker Hub (https://hub.docker.com/repository/docker/mkrooted/imbg-fastlbp/general).
Seehttps://github.com/imbg-ua/fastLBP-sandboxfor detailsGuidesHow to build and deploy a pip packageSrc:https://packaging.python.org/en/latest/tutorials/packaging-projects/Add your access token to.pypirc# ~/.pypirc 
[pypi]
  username = __token__
  password = pypi-TOKEN_FROM_YOUR_PYPI_SETTINGS_GOES_HEREEnsure that your Python is 3.8 because the package targets Python 3.8 and thus requires to be build using this Python versionpython --version
# Should show Python 3.8.somethingInstall prerequisites (twineandbuild)pip install --upgrade twine buildEdit project version inpyproject.tomlBuild and upload the project# while in root project directory
python -m build      # .whl and .gz output will be at ./dist directory
python3 -m twine upload dist/*   # note that this can accidentally upload unneeded buildsAlgorithm notesStep 1 performs an LBP and creates histograms for eachmethod.Methodis a combination of the following parameters:image nameimage channelLBP radiusLBP number of pointsEvery method's result got saved into the separate.npyfile. There is a correspondence betweeen a method and a computational job.Step 2 collects all the results and concatenate them along the features dimension.
That means that feature vector of a patch is a concatenation of all LBP codes from all channels and all LBP radii.
Package: fastlbp-imbg
fastLBPHighly parallel LBP implementationInstallationNote: it is not recommended to proceed on a head node; consider starting an ijob or a jupyter instance.Activate a Python 3.11 environment (e.g. usingconda create -y -n p11 python=3.11 && conda activate p11)Verify you are using the right envpython --versionтаpip --versionInstall a stable version from PyPIpip install fastlbp-imbgOr build the latest version from sourcesgit clone git@github.com:imbg-ua/fastLBP.git
cd fastLBP
# git checkout <branchname> # if you need a specific branch
pip install . # this will install the fastlbp_imbg package in the current envYou can useimport fastlbp_imbgnowCython2 branch detailsTODO:Data Contiguity (e3293cd)Job sorting (from slow to quick) in fastlbp.py (8a21a04)Change data types in lbp.pyx from float64 to something smaller (f177823)Add mask feature to lbp.pyx (d70bc93)Add mask feature to fastlbp.py (d812831)Fill all commit numbersImplemented modulesrun_skimageComputes multiradial LBP of a single multichannel image in a parallel fashion.This is a quick sample implementation that could be a baseline for further benchmarking.Features:Powered byskimage.feature.local_binary_patternConcurrency is managed by Python'smultiprocessingmoduleParallel computation viamultiprocessing.Poolof sizencpusEfficient memory usage viamultiprocessing.shared_memoryto make sure processes do not create redundant copies of dataIt computes everything in RAM, no filesystem usageTODO:Usemax_ramparameter to estimate optimal number of sub-processes and collect memory stats. Nowmax_ramis ignored.Planned modulesrun_chunked_skimageSimilar to1. run_skimage, but each subprocess should compute LBP for its image chunk, not the whole image.run_dask and run_chunked_daskSimilar to1. run_skimage, but useDaskanddask.array.map_overlapfor parallelisation instead ofmultiprocessingand manual data wranglingOther notable things to tryPerform benchmarking of an in-house optimised cython version ofskimage.feature.local_binary_pattern(seeskimage_lbp.pyx at imbg-ua/nf-img-benchmarking)Do some research on Numba - is it applicable here?Add annotations to run_skimage results usinganndata
Package: fastlens
fastlens:Public package of FFT based evaluation of extended source magnification,fastlens, which is named afterfast microlensing.
Please citeSugiyama 2022.FFT based method of extended soruce magnification is implemented infastlens/mag_fft.py.
FFT based method of time averaged magnification is implemented infastlens/timeave.py.Please cite my paper if you use my code for your project.FFT based method uses public FFTLog code by Xiao Fang, available atFFTLog-and-beyond, and developed inFang et al (2019); arXiv:1911.11947.fastlensis open source and distributed withMIT license.InstallationThis package is installable with both of pip and conda. Just install by running below on your shellpip install fastlensfor pip user, orconda install -c XXX fastlensfor conda user.If you prefer to download the repo and install the package from source, runpython setup.py installContents: notebooks and a scriptAll the ipython notebooks are saved inipynbdirecotry. Tutorials are available inhowtouse.ipynbshows how to use module inmagnification.howtouse-previous-methods.ipynbshows how to use modeles for methods developed in the previous studies.
Validation and comparison to previous methods are performed intimeave.ipynbvalidate the accuracy of implementation of time averaging effect with FFT.comparison.ipynbmakes a plot of comparison of residuals by various evaluation methods of extended source magnification.timeit_methods.ipynbmeasures computational time of various methods.paperfig.ipynbcan reproduce figures shown in the paper.testdata.pyis a module to generate reference magnification usingscipy.integrate.quad, which will be used for validation of the FFT based method.
Package: fastlevenshtein
ContentsIntroductionInstallationUsageLicenseIntroductionRust implementation of levenshtein distance (https://en.wikipedia.org/wiki/Levenshtein_distance), based on Wagner–Fischer_algorithm (https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm).Installationpip install fastlevenshteinUsageFirst param is either a list or a str.It will be compared to the second param that is a str.The third param is the maximum value of levensthein.
For example, if the third param is 3, if the levensthein value reach at least 3, the function with exit and return 3 as value.
This third param is used to increase computation time when you are only interested in string that are close to each other.
If you do not want to use early exit, you can just use a really high value for this paramfrom fastlevenshtein import levenshtein
levenshtein("string1", "string2", 999) # 999 so no early exit
>>> 1

from fastlevenshtein import levenshtein_list
levenshtein_list(["string1", "string2"], "string3", 999)
>>> [1, 1]

from fastlevenshtein import levenshtein_list
levenshtein_list(["aaaaaaaa", "bbbbbbbb"], "ccccccc", 3) # early exit at 3 maximum value for levensthein distance
>>> [3, 3]Licensefastlevenshtein 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 2 of the License, or (at your option)
any later version.See the file COPYING for the full text of GNU General Public License version 2.
Package: fastlexrank
FastLexRankA streamlined and approximate implementation of the LexRank algorithm for rapid text summarization.LexRank for large scale dataThe original implementation of LexRank utilizes the power method to calculate the eigenvector associated with an eigenvalue of 1. In the foundational paper by Erkan and Radev[1], they mathematically demonstrated why the normalized similarity matrix is a stochastic matrix and will, therefore, converge.However, a key challenge with the original LexRank algorithm is its dependence on the power method, which often requires multiple iterations to converge. For a large corpus, matrix multiplication can become a bottleneck, slowing down the computation considerably.To address this issue, we introduce an approximate approach that efficiently computes a score for each sentence while retaining the essential characteristic of relative centrality. Our modified method offers significant speed improvements in LexRank calculations and delivers reliable results.Reference[1]Erkan, G., & Radev, D. R. (2004).Lexrank: Graph-based lexical centrality as salience in text summarization.Journal of artificial intelligence research, 22, 457-479.
Package: fastlid
fastlid[]Language identification based on fasttext (lid.176.ftzhttps://fasttext.cc/docs/en/language-identification.html).Thelid.176.ftzfile is licensed under  Creative Commons Attribution-Share-Alike License 3.0 and is not part of this module. It is automatically downloaded from its external origin on the first run of this module.This module attempts to immitate the follow two features oflangidlangid.classify: fastlidlangid.set_languages(langs=[...]): fastlid.set_languages = [...]import fastlidfastlid.set_languages = ['nl','fr'])TODO: Commandline interfacePreinstall fasttext for Windows without C compilerpip install fasttextFor Windows without a C/C++ compiler:Download a proper whl (e.g.,fasttext‑0.9.2‑cp36‑cp36m‑win_amd64.whlfor 64bits Python 3.6 etc)  fromhttps://www.lfd.uci.edu/~gohlke/pythonlibs/#fasttextpipinstallfasttext*.whlor (for python 3.8)pip install https://github.com/ffreemt/ezbee/raw/main/data/artifects/fasttext-0.9.2-cp38-cp38-win_amd64.whlInstall itpipinstallfastlidor install fromgitpipinstallgit+https://github.com/ffreemt/fast-langid.git# also works pip install git+https://github.com/ffreemt/fast-langidor clone the git repo and install from source.Use itfromfastlidimportfastlid,supported_langs# support 176 languagesprint(supported_langs,len(supported_langs))# ['af', 'als', 'am', 'an', 'ar', 'arz', 'as', 'ast', 'av', 'az'] 176fastlid("test this")# ('en', 0.765)fastlid("test this 测试一下",k=2)# (['zh', 'en'], [0.663, 0.124])fastlid.set_languages=['fr','zh']fastlid("test this 测试吧")# ('zh', 0.01)fastlid.set_languages=Nonefastlid("test this 测试吧")('en',0.686)fastlid.set_languages=['fr','zh','en']fastlid("test this 测试吧",k=3)(['en','zh','fr'],[0.686,0.01,0.006])N.B.hanzidentifiercan be used to identify simplified Chinese or/and traditional Chinese should you need to do so.For DevelopersInstallpoetryandyarnthe way you like it.poetryinstall# install python packagesyarninstall--dev# install necesary node packages# ...code...yarntestyarnfinal# ...optionally submit pr...
Package: fastlife
Fast LifeFast Life is an experiment in Python simulation performance. Python has many excellent simulation frameworks includingSimPyandMESA, which make it easy to conduct simulations for research and experimental purposes. Fast Life is not intended to be a simulation framework in the same way, instead Fast Life is designed to answer the question: "Can Python be used to create extremely large scale simulations"? To this end, Fast Life implements a seemingly simple simulation:Conway's Game of Life-- but scales it up to massive proportions. We then explore several different implementations including:Pure Python SequentialPure Python MultiprocessingC-bindings SequentialC-bindings ParallelEach of these implementations will be benchmarked with significantly sized worlds and the same random seeds to determine how their performance scales. Please seefastlife.readthedocs.iofor more details and the complete write up on the documentation.Quick StartInstall the package and the command line tool using the Python package manager as follows:$ pip install fastlifeAlternatively, if you're interested in development, you can download the repository, cd into it and install locally with:$ git clone https://github.com/bbengfort/fastlife.git
$ cd fastlife
$ pip install -e .Note that if you're developing, you should probably set up a virtualenv and all of that good stuff before doing this step. Once done, you should have a CLI scriptfastlifeinstalled on your path, check it out as follows:$ fastlife --helpTo run a simulation and see the animated action, you would usefastlife run -a- you can play with the various settings and commands to see different implementations of the simulation.
Package: fastlingo
FastLingo is a command-line tool designed to translate iOS app metadata using a variety of translation sources. It is built on top ofFastlaneandDeliver. FastLingo is currently supports the following translation sources:Google Cloud Translation APIFull documentation can be foundhere.FeaturesMultilingual app metadata translation.Configurable translation sources.Translation caching for enhanced performance and fewer API calls.Seamless integration with Fastlane metadata folder structure.InstallationTo install FastLingo, execute the following command:pipinstallfastlingoConfigurationBefore using FastLingo, configure your preferred translation source by establishing API keys and endpoints. Generate a template configuration file by executing:fastlingoinitThis action creates aFastLingo.tomlfile in the current directory, which can then be edited to include your API keys and endpoints. For example, to configure the Google Cloud Translation API, add the following to your configuration file:translation_service="google"source_language="ENGLISH"target_languages=["AUTO",]metadata_folder="your/metadata/folder"fields_to_translate=["name","description"][api_keys]google="service/account/key.json"[cache]cache_folder=".fastlingo-cache"cache_enabled=trueHow to UseTo translate your app metadata, run:fastlingotranslateThis will translate all the metadata fields specified in your configuration file for each target language.ContributingPull requests are welcome. Additions to the translation source list are encouraged.LicenseFastLingo is available under the MIT license.
Package: fast-link-extractor
Fast Link ExtractorProject under active deveopmentA Python 3.7+ package to extract links from a webpage. Asyncronous functions allows the code to run fast when extracting from many sub-directories.A use case for this tool is to extract download links for use withwgetorfsspec.Main base-level functions.link_extractor(): extract links from a given URLInstallationPyPipipinstallfast-link-extractorExampleSimply import the package and calllink_extractor(). This will output of list of extracted linksimportfast_link_extractorasfle# url to extract links frombase_url="https://www.ncei.noaa.gov/data/sea-surface-temperature-optimum-interpolation/v2.1/access/avhrr/"# extract all links from sub directories ending with .nc# this may take ~10 seconds, there are a lot of sub-directorieslinks=fle.link_extractor(base_url,search_subs=True,regex='.nc$')If using inside Jupyter or IPython, setipython=Trueimportfast_link_extractorasfle# url to extract links frombase_url="https://www.ncei.noaa.gov/data/sea-surface-temperature-optimum-interpolation/v2.1/access/avhrr/"# extract all links from sub directories ending with .nc# this may take ~10 seconds, there are a lot of sub-directorieslinks=fle.link_extractor(base_url,search_subs=True,ipython=True,regex='.nc$')ToDomore tests: need more testsdocumentation: need to setup documentation
Package: fastlmm
FaST-LMMFaST-LMM, which stands for Factored Spectrally Transformed Linear Mixed Models, is a program for performing
genome-wide association studies (GWAS) on datasets of all sizes, up to one millions samples.This release contains the following features, each illustrated with an IPython notebook.Core FaST-LMM (notebook) --Lippertet al.,Nature Methods2011Improvements:New features for single_snp (including effect size and multiple phenotype support) and epistasis (including reporting beta and using pre-computed eigenvalue decompositions) (notebook)  --Lippertet al.,Nature Methods2011Ludicrous-Speed GWAS (notebook) --Kadie and Heckerman,bioRxiv2018Heritability with Spatial Correction (notebook),Heckermanet al.,PNAS2016Two Kernels (notebook) --Widmeret al.,Scientific Reports2014Set Analysis (notebook) --Lippertet al.,Bioinformatics2014Epistasis (notebook) --Lippertet al.,Scientific Reports,2013Prediction (notebook) --Lippertet al.,Nature Methods2011A C++ version, which is generally less functional, is available. Seehttp://fastlmm.github.io/.Quick install:pip install fastlmmFor best performance, be sure your Python distribution includes a fast version of NumPy. We use Anaconda'sMiniconda.DocumentationIPython Notebooks:Core, Epistasis, Set Analysis, Two KernelsMultiple-Phenotype GWAS and related featuresHeritability with Spatial CorrectionLudicrous-Speed GWASMain DocumentationProject Home and Full Annotated BibliographyCodePyPiGitHubContactsEmail the developers atfastlmm-dev@python.org.Jointhe user discussion and announcement list (or useweb sign up).Open an issueon GitHub.
Package: fastload
fastloadFastLoad downloads files faster using the same technology as IDM aiming to utilize the maximum available bandwidth for faster downloading.InstallationUse the package managerpipto install fastload.pipinstallfastloadUsagefromfastloadimportFastLoaddefmain():# e.g: https://www.cdn.xyz.mp4url='<absolute_url_of_the file>'# Initialize the downloaderfastload=FastLoad(url=url)# Start downloadingfastload.download()if__name__=='__main__':main()History0.0.3Bug Fix.0.0.2Added a README.md file.Minor changes.0.0.1First release on PyPI.
Package: fastlogfileparser
FastLogfileParserParse logfiles from computational chemistry software, but fast-lyInstall withpip install fastlogfileparserorconda(forthcoming!).~10x faster thancclibzerodependencies, supports all modern Python versionSupports linked jobs, returns a separate result dictionary for each jobRetrieves values at every step, not just convergenceUsageGaussianThere is a single functionfast_gaussian_logfile_parserinsidefastlogfileparser.gaussianwhich reads logfiles and returns the result as anamedtuple(which prevents accidentally changing the values and allows using.syntax to access them).Usage Examplefromfastlogfileparser.gaussianimportfast_gaussian_logfile_parserasfglp# read all jobs from the logfilejob_1,job_2,...,job_n=fglp("data/result.log")# access resultsprint(job_1.frequency_modes)# show all available values retrieved from the fileprint(job_1._fields)# can also be accessed viafromfastlogfileparser.gaussianimportFIELDSFast logfile parser is fastest when you ask it to retrieve only the fields you want, i.e.:job_1,job_2,job_3=fglp(FNAME,get=("gibbs","scf"))Retrieved ValuesQuantityKeyTypeFrequencyGibbs free energy at 298Kgibbsfloat1/jobGibbs free energy at 0Ke0_zpefloat1/jobEnthalpy at 298Ke0_hfloat1/jobE0 $^1$E0float1/jobPer-atom Zero Point Energyzpe_per_atomfloat1/jobStandardized xyz coordsstd_xyzlist[float]1/step/job............Number of Atoms $^2$number_of_atomsint1/jobNumber of Optimization Steps $^2$number_of_optimization_stepsint1/job$1$ equals E0 only for non-wavefunction methods$2$ requiresstd_xyzto be parsed to find these valuesHow much fast-ly-er?FastLogfileParseruses REGEX and only REGEX to retrieve data from logfiles, spending as much time in Python's excellent C-based REGEX library as possible.Seecomparison.pyto run for yourself (install withpip install .[demos]), but in short:compared tocclib,fastlogfileparseris ~10x as fast and returns all values for intermediate steps in simulation (butcclibsupports retrieving a different set of values)compared toase,fastlogfileparseris ~2x slower, but returnsfar morevalues and in a more readily accessible formatDevelopment NotesFastLogfileParseris written in a purely functional style.Running TestsInstallFastLogfileParserwith the optional[dev]dependencies, i.e. from a local clone run `pip install -e ".[dev]"Rather than keep the gigantic log files saved in the git repo directly, they are compressed to make cloning easier.
Before running tests, navigate totestand runpython data_loader.py decompressto prepare the needed logfiles.To add new data for the tests to the repo, perform the previous step and then runpython data_loader.py compress.
This may take some time to finish executing (a minute or so).
Package: fastlogranktest
Perform the Log-Rank-Test very fastFree software: BSD licenseDescriptionCalculate the Log-Rank-Test very fastInstallationpip install fastlogranktest(if it fails, make sure python-dev is installed and try the installation again.linux: sudo apt-get install python-dev)Usagelogrank_test(groupa, groupb, groupacensored, groupbcensored)Argumentsgroupa:
list of group a’s survival timesgroupb:
list of group b’s survival timesgroupacensored:
list of censored information of group a’s survival timesgroupbcensored:
list of censored information of group b’s survival timesValuep-valueDescriptionCalculate multiple Log-Rank-Tests very fast using threadingUsagemulti_logrank_test(groupas, groupbs, groupacensoreds, groupbcensoreds, threadnumber = NULL)Argumentsgroupas:
list of lists of groupa’s survival timesgroupbs:
list of lists of groupb’s survival timesgroupacensoreds:
list of lists of censored information of groupa’s survival timesgroupbcensoreds:
list of lists of censored information of groupb’s survival timesthreadnumber:
(optional) set the number of threads used for this functionValuelist of p-values (same order as input)History0.1.0 (2019-10-21)First release on PyPI.0.1.1 (2019-10-22)Updated programm instructions.0.1.2 (2019-11-05)Updated programm instructions again.0.1.3 (2019-11-05)Updated link to gitlab.0.1.4 (2019-11-07)Improvements for Linux compatibility.0.1.5 (2019-11-07)Improvements for Linux compatibility.0.1.6 (2019-11-07)Improvements for Linux compatibility.0.1.7 (2019-11-07)Improvements for Linux compatibility.0.1.8 (2019-11-07)Improvements for Linux compatibility.0.1.9 (2019-11-07)Improvements for Linux compatibility.0.2.0 (2019-02-01)Updated installation and author information.
Package: fast-luhn
Luhn-algorithm. Generate and validate strings of numbers.
It is used for account number validation, credit card validation, data verification, cryptography, decoding, etcetera.
Rust realization for speed-up python code. Thread-safe. Seebenchmarkfor details.Author:Matt StroganovVersion:0.1.5InstallationInstall with pip:$ pip install fast-luhnUsageImport package:>>>importfast_luhnasflValidateCheck ifstringis valid by luhn algorithm. Returnbool.>>>fl.validate("471629309440")FalseDigitCalculate next digit for string of numbers. Returnint.>>>fl.digit("47162930944")7CompleteAdd luhn-check digit to string of numbers. Returnstring.>>>fl.complete("2398560146")'23985601469'GenerateGenerate luhn-valid string of numbers withlength. Returnstring.>>>fl.generate(50)'58126333877729238938910323395262199130041545367401'BuildInstall from sources:$ git clone https://github.com/cybermatt/fast-luhn
$ cd fast-luhn
$ pip install -r requirements-dev.txt
$ python ./setup.py developBenchmarkPure python realization (fromhere) was very slow.Comparison with popular python Luhn modules:method libluhnLAPfast-luhnvalidate4.65 µs13.3 µs0.2 µsgenerate48.1 µs94.4 µs3.17 µsEnvironment:CPU i5-6500 3.20GHz, 16gb RAMLinux 4.19Python 3.7.3Tests$ pytest -v tests.pyLicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details
Package: fastluks
fastluksPython scripts for storage encryption through LUKS. Converted into a python package fromfast-luksandluksctlFor this package to work properly, both the installation and usage procedure must be run as superuser either in an Ubuntu or CentOS machine.InstallationThe procedure to setup a virtual environment and install the package on CentOS is the following:yuminstall-ypython3
python3-mvenvvenv
.venv/bin/activate
pipinstallfastluksTo do the same on Ubuntu:apt-getupdate
apt-getinstall-ypython3python3-pippython3-venv
python3-mvenvvenv
.venv/bin/activate
pipinstallfastluksUsage: fastluksTo perform encryption and volume setup with default parameters, thefastlukscommand can be used inside the virtual environment:fastluksThe encryption passphrase can be stored locally and/or on Hashicorp Vault.To store the passphrase locally:fastluks--save-passphrase-locallyTo store the passphrase on Vault, the flag--vaultmust be used with the required arguments specified:fastluks --vault --vault-urlurl--wrapping-tokentoken--secret-pathpath--user-keykeyUsage: luksctlIn order to manage a volume encrypted with fastluks, the commandluksctlcan be used from the command line:# Display volume statusluksctlstatus# Open encrypted volumeluksctlopen# Close encrypted volumeluksctlclose