Saravanan666/pypi-org huggingface dataset:
Package: fcdproc
fcdprocis a Nipype-based processing application that detects subtle Focal Cortical Dysplasia (FCD)
lesions in MRI negative Epilespy patients.This application is easily installable, requires minimal user input, and only a small training set of normative data and FCD lesions.Python package for detection of subtle focal cortical dysplasia (FCD) lesions in MRI negative epilepsy patientsFree software: Public DomainDocumentation:https://inatilab.github.io/fcdproc.## ContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.## Licensefcdprocwas created by InatiLab. It is licensed under the terms of the GNU General Public License v3.0 license.
Package: fcdstools
Famicom Disk Systemdisk image manipulation tools.fdscheckcan recognize game titles with the internal database.
This database is converted fromFDS Study database,
and it is originally developed byenaandgponys. Thanks for the great
work and the permission to use!Usagecheck:$ fdscheck game.fds                 # with internal database
$ fdscheck --db fdsdb.json game.fds # with custom database
$ fdscheck --nodb game.fds          # without databasesplit:$ fdssplit game.fdsbuild:$ fdscheck -f manifest game.fds > manifest.json
$ fdssplit game.fds
... (modify files)
$ fdsbuild out.fds manifest.jsonconvert FDS Study database into JSON:$ fdssjson fdsdb-be.txt > fdsdb.jsonTo convert Japanese database, encoding conversion is needed:$ iconv -f cp932 -t utf-8 fdsdb-bj.txt > fdsdb-bj-utf8.txt
$ fdssjson fdsdb-bj-utf8.txt > fdsdb-ja.jsonInstall$ pip install .DependencyPython >= 3.6setuptoolskaitaistructtabulateTo compile*.ksyfiles by yourself, HEAD ofkaitai-struct-compileris required.Resourcesnesdev wikigponys’ FDS resourcesEnri’s FDS pageCreditsenadevelopedFDS Study.gponysis maintainingFDS Study unofficial database.
Package: fcd-torch
Fréchet ChemNet Distance on PyTorchPyTorch implementation ofFréchet ChemNet Distanceported from the original repositoryhttps://github.com/bioinf-jku/FCD. The ported model produces the same outputs as the original Keras implementation and can be used for reproducible research. The PyTorch model of ChemNet weights tenfold less, resulting in faster loading.Other features:You can precalculate mean and sigma for further usage, useful if you use the statistics from the same dataset multiple timesSupports calculation on GPU and selection of GPU device numberMultithreaded SMILES parsingInstallationFirst, installRDKit:conda install -yq -c rdkit rdkitand then installfcd_torchfrom pip (pip install fcd_torch), or directly from the source:git clone https://github.com/insilicomedicine/fcd_torch.git
cd fcd_torch
python setup.py installUsageImport the modulefrom fcd_torch import FCD. You can run calculation directly or precalculate statistics to reuse them on the test set (see example below). If you run FCD on GPU, the GPU memory will be allocated only during calculation of FCD.# Example 1:fcd=FCD(device='cuda:0',n_jobs=8)smiles_list1=['COc1cccc(NC(=O)Cc2coc3ccc(OC)cc23)c1','Cc1noc(C)c1CN(C)C(=O)Nc1cc(F)cc(F)c1']smiles_list2=['Oc1ccccc1-c1cccc2cnccc12','Cc1noc(C)c1CN(C)C(=O)Nc1cc(F)cc(F)c1']fcd(smiles_list1,smiles_list2)# Example 2:fcd=FCD(device='cuda:0',n_jobs=8)smiles_list1=['COc1cccc(NC(=O)Cc2coc3ccc(OC)cc23)c1','Cc1noc(C)c1CN(C)C(=O)Nc1cc(F)cc(F)c1']smiles_list2=['Oc1ccccc1-c1cccc2cnccc12','Cc1noc(C)c1CN(C)C(=O)Nc1cc(F)cc(F)c1']pgen=fcd.precalc(smiles_list2)fcd(smiles_list1,pgen=pgen)For the constructor, you can pass the device asdevice='cpu'for CPU anddevice='cuda:n'for GPU, wherenis the GPU device number.n_jobsparameter specifies the number of threads for parsing SMILES. You can also vary thebatch_sizeparameter. Call parameters for FCD arefcd(ref=None, gen=None, pref=None, pgen=None), where you should specify eitherref(SMILES list), orpref(precalculated statistics), and the same forgenandpgen.
Package: fcgiapp
fcgiapp is a Python wrapper for the C FastCGI SDK.  It’s used by PEAK’s FastCGI servers to provide WSGI-over-FastCGI.  Originally created and maintained by Digital Creations (now Zope Corp.), it is now being maintained as one of PEAK’s adopted “orphan” projects.  A POSIX-like operating system (Linux, Mac, Cygwin, etc.) is required, since Unix-domain socket use is hardwired in the original package.
Package: fcgiproto
TheFastCGIprotocol is a protocol commonly used to relay HTTP requests and responses between a
front-end web server (nginx, Apache, etc.) and a back-end web application.This library implements this protocol for the web application end as a pure state-machine which
only takes in bytes and returns a list of parsed events. This leaves users free to use any I/O
approach they see fit (asyncio,curio,Twisted, etc.). Sample code is provided for implementing
a FastCGI server using a variety of I/O frameworks.Project linksDocumentationSource codeIssue tracker
Package: fchart3
Fchart3Fchart3 is a project designed to create high quality astronomical charts. It is written in Python using data from Stellarium, Kstars and HnSky, including 300 million stars. It can be used to create both offline charts with output to PDF or online interactive charts as can be seen in the case of projectCzSky.Online interactive version is available on projectCzSky:https://www.czsky.eu/chart?ra=1.532197702857378&dec=0.06961660554646551&fsz=100&splitview=trueInstall:Download this project andpython setup.py installRun:fchart3 --helpto show commandline options.The sources of original project fcharts can be found at:https://www.astro.rug.nl/~brentjen/fchart.htmlHowever it relies on numarray which has been deprecated in favor of numpy.Previous fchart sources for python2.7 can be found at:https://github.com/Fingel/fchartThis repository contains updated sourcecode so that the code may run with numpy.This repository also contains following catalogs in the data/catalogs directory:bsc5.datcatalogue ofbright starsconstbnd.datCatalogue of Constellation Boundary Dataconstellationship_western.fab- western constellation lines from Stellariummilkyway.dat- outlined Milky Waymilkyway_enhanced.dat- shaded Milky Waydeep_sky.hnd- catalog of deepsky objects from Hnsky created by Han Kleijn (https://www.hnsky.org/software.htm)namedstars.dat- catalog of named stars fromkstarsoutlines_catgen.dat- nebulae outlines fromOpenNGCPGC.dat- catalogue of PGC galaxiesPGC_updates.dat- actualizations of PGC cataloguestarnames.dat- star names fromkstarsstars_0_0v*.cat- UsnoNomad catalogs fromstellariumunamedstars.dat- catalog of unamed stars fromkstarsAuthorsMichiel Brentjens - original authorAustin Riba - modern fchart for python 2.7, numpy.https://github.com/Fingel/fchartVladimir Dvorak - fchart3: python3 + pycairo support. Rectangular view, constellations shapes, borderlines. Support for stars up to 16mag using HTM (hierarchical triangular mesh) and USNO NOMAD catalog.
Package: fchecker
fcheckerfchecker is designed to provide cleaner useable check exceptions. The "f" in fchecker represents formatted.The purpose of fchecker is not to replace some of the built-in Python general checks but to act as a companion to enhance messages and increase issue resolution.All check exceptions will return with no trackback from the checker. All tracing will get displayed from the caller line. Inspecting the original traceback will show all traces, but general usage and return output will not show any traces of the backend calls.Returned exceptions are formatted usingfexception. Import the required fexception exception classes for exception handling.DescriptionPython's general checks return True or False when a check result gets returned. fchecker not only offers the ability to return True or False but, by default, throws a cleanly written exception when a check does not pass.. fchecker checks many different Python checks and adds the ability to wrap a clean formatted structure around the returned exception.Available ChecksBelow are the listed check options. Some options are methods, and some are functions. Proper formatting is used to distinguish between the two. Please read the docstring for more details on usage requirements.Import NameMethod or FunctionCheckingOverviewKeyCheckMethodDictionaryAn advanced dictionary key checker that offers two different check options.1. Checks if some required keys exist in the dictionary.2. Checks if all required keys exist in the dictionary.type_checkFunctionTypeA simple type validation check.Offers optional caller_override to change traceback.file_checkFunctionFileChecks if the file exists.InstallationFrom PyPIYou can find fchecker on PyPI.https://pypi.org/project/fchecker/UsageOnce installed, add fchecker as a module and select the checker option from the import.Note: You can use * to import all check options.
Package: fchic
fchicfchic is a tiny library for parsingGaussian formatted
checkpoint filesinto python data structures.
To use it, simply point it at a file and give it a deck to load, like so:importfchicwithopen("data.fchk","r")asf:out=fchic.deck_load(f,"Cartesian Gradient")outis now a list of3 x Nfloating point numbers parsed from theCartesian Gradientsection ofdata.fchk.Note:fchic does no data validation (beyond shape and type), no physical
unit conversions and no integration into fancy data structures. It is entirely
a single page, simplepyparsinggrammar. You'll need to do your own data processing from its outputs.Usagefchic consists of two functions:fchic.load(fp)transform a formatted checkpoint file in from a file-like
objectfpinto a python dictionary of decks.fchic.deck_load(fp, name)loads the specific decknamefrom file-like
objectfp.Versions of those functions that acts on strings (fchic.loads()andfchic.deck_loads) are also provided.Decks are returned thinly parsed from the formatted checkpoint files:Integer values (typeI) are parsed into lists of pythonint.Real values (typeR) are parsed into lists of pythonfloat.Char values (typeC) are parsed into a unary list containing a string.Python is not exactly fast, and neither is pyparsing, so you'll generally want
to usefchic.deck_load()which does not have to parse the whole file, and is
therefore way way 🐇 faster 🐇.InstallationpipinstallfchicLicensefchic is provided under the MIT license.
Package: fcid
fcidThanks to:https://www.biostars.org/p/198143/https://github.com/10XGenomics/supernova/blob/master/tenkit/lib/python/tenkit/illumina_instrument.py#L12-L45Illumina Techinical SupportDisclaimer: this is not a replacement for proper sequencing run tracking.
Disclaimer: PRs welcome to fill gaps!  Instrument IDs are less reliable as those are often changed by the sequencing center.Installationpip install fcid
# or, for you devs
git clone <this repo> && cd fcid
pip install --editable .Usage (CLI)# fcid CABBCANXX
# fcid  K11111 --by-machine
# fcid 22C37GLT3Usage (package)
Package: fcio
InstallationRunpython3 -m pip install fcioto install from the pypi repository.Descriptionfcio-pyprovides a read-only wrapper around thefcio.cio library used infc250bbased digitizer systems.The wrapper exposes thefcio.cmemory fields as closely as possible to standard c-structs using numpy ndarrays or scalars where applicable.
For convenience all supported fcio records are exposed as iterable properties of the baseFCIOclass to preselect records of interest.UsageSimple code exampleThe following example opens an fcio file and prints some basic event content to stdout:fromfcioimportfcio_openfilename='path/to/an/fcio/file'withfcio_open(filename,extended=True)asio:print("#evtno run_time utc_unix_sec utc_unix_nsec ntraces bl_mean bl_std")foreventinio.events:print(f"{event.eventnumber}{event.run_time:.09f}{event.utc_unix_sec}{event.utc_unix_nsec}{event.trace_list.size}{event.fpga_baseline.mean():.1f}{event.fpga_baseline.std():.2f}")Differences to C usagefcio-pycodifies the assumption that aFCIOConfigrecord must be available and skips all previous records on openingreading of zstd or gzip compressed files is possible using suprocesses. This requireszstdorgzipto be available. If a file ends in.zstor.gzrespectively and thecompressionparameter is default, this will happen automatically.DevelopmentDevelopment is best done in a local environment, e.g. usingvenv:# create local environment:
export MY_ENV=fcio_dev
python3 -m venv $MY_ENV

# activate the environment
source $MY_ENV/bin/activateThis library depends onmeson-python/mesonas build tool andCython/numpyto wrap thec-sources. These should be installed automatically wenn runningpython3 -m build.
To allow a more traditional workflow a thinMakefileis available which wraps thepython3andmesonspecific commands.
Package: fcis
chainer-fcis - FCIS===================[![PyPI Version](https://img.shields.io/pypi/v/fcis.svg)](https://pypi.python.org/pypi/fcis)![Build Status](https://travis-ci.org/knorth55/chainer-fcis.svg?branch=master)![Example](static/coco_example.png)This is [Chainer](https://github.com/chainer/chainer) implementation of [Fully Convolutional Instance-aware Semantic Segmentation](https://arxiv.org/abs/1611.07709).Original Mxnet repository is [msracver/FCIS](https://github.com/msracver/FCIS).Requirement------------ [CuPy](https://github.com/cupy/cupy)- [Chainer](https://github.com/chainer/chainer)- [ChainerCV](https://github.com/chainer/chainercv)- OpenCV2Additional Requirement----------------------- For COCO Dataset class- [Cython](http://cython.org/)- [pycocotools](https://github.com/cocodataset/cocoapi)- For COCO Training- [OpenMPI](https://www.open-mpi.org/)- [nccl](https://developer.nvidia.com/nccl)- [ChainerMN](https://github.com/chainer/chainermn)Notification------------- Only GPU implementation, No CPU implementation yet.TODO----- VOC- [x] Reproduce original repo training accuracy- [ ] Refine evaluation code- COCO- [ ] Reproduce original repo training accuracy- [ ] Refine evaluation codeInstallation------------We recommend to use [Anacoda](https://anaconda.org/).```bash# Requirement installationconda create -n fcis python=2.7conda install -c menpo opencvpip install cupy# Installationpip install fcis```Inference---------```bashcd examples/coco/python demo.py```Above is our implementation output, and below is original.<img src="static/output.png" width="60%" ><img src="static/original_output.png" width="60%" >Training--------```bashcd examples/voc/python train.py```LICENSE-------[MIT LICENSE](LICENSE)Powered by [DL HACKS](http://deeplearning.jp/hacks/)
Package: fcit
.. image:: https://img.shields.io/badge/License-MIT-yellow.svg:target: https://opensource.org/licenses/MIT:alt: License*A Fast Conditional Independence Test (FCIT).*Introduction-----------Let *x, y, z* be random variables. Then deciding whether *P(y | x, z) = P(y | z)*can be difficult, especially if the variables are continuous. This packageimplements a simple yet efficient and effective conditional independence test,described in [link to arXiv when we write it up!]. Important features that differentiatethis test from competition:* It is fast. Worst-case speed scales as O(n_data * log(n_data) * dim), where dim is max(x_dim + z_dim, y_dim). However, amortized speed is O(n_data * log(n_data) * log(dim)).* It applies to cases where some of x, y, z are continuous and some are discrete, or categorical (one-hot-encoded).* It is very simple to understand and modify.* It can be used for unconditional independence testing with almost no changes to the procedure.We have applied this test to tens of thousands of samples of thousand-dimensional datapoints in seconds. For smaller dimensionalities and sample sizes, it takes a fraction of a second. The algorithm is described in [arXiv link coming], where we also provide detailed experimental results and comparison with other methods. However for now, you should be able to just look through the code to understand what's going on -- it's only 90 lines of Python, including detailed comments!Usage-----Basic usage is simple, and the default settings should work in most cases. To perform an *unconditional test*, use dtit.test(x, y):.. code:: pythonimport numpy as npfrom fcit import fcitx = np.random.rand(1000, 1)y = np.random.randn(1000, 1)pval_i = fcit.test(x, y) # p-value should be uniform on [0, 1].pval_d = fcit.test(x, x + y) # p-value should be very small.To perform a conditional test, just add the third variable z to the inputs:.. code:: pythonimport numpy as npfrom fcit import fcit# Generate some data such that x is indpendent of y given z.n_samples = 1000z = np.random.dirichlet(alpha=np.ones(2), size=n_samples)x = np.vstack([np.random.multinomial(20, p) for p in z]).astype(float)y = np.vstack([np.random.multinomial(20, p) for p in z]).astype(float)# Check that x and y are dependent (p-value should be uniform on [0, 1]).pval_d = fcit.test(x, y)# Check that z d-separates x and y (the p-value should be small).pval_i = fcit.test(x, y, z)Installation-----------pip install fcitRequirements------------Tested with Python 3.6 and* joblib >= 0.11* numpy >= 1.12* scikit-learn >= 0.18.1* scipy >= 0.16.1.. _pip: http://www.pip-installer.org/en/latest/
Package: f-ck
fuckFuck: anultimatecensorshipkiller - a tiny program for uncensoring russian textsUsageTo uncensor a particular text use command like this:python-mfuckuncensor'Нах**я до%@я нах%ярил??? Расх*%яривай нах@й - не дох*ярим. Них*я, не дох@я дох%ярим - пох*ярили'The command will emit an uncensored text:Нахуядохуянахуярил???Расхуяривайнахуй-недохуярим.Нихуя,недохуядохуярим-похуярилиTo get the same result in a python command seethe example:fromfuckimportProfanityHandlertext,censored,unhandled_matches=ProfanityHandler(path='assets/profane-words.txt').uncensor('Нах**я до%@я нах%ярил??? Расх*%яривай нах@й - не д0х*ярим. Них*я, не дох@я дох%ярим - пох*ярили')print(text)print(censored)print(unhandled_matches)The script generates the following output upon execution:Нахуядохуянахуярил???Расхуяривайнахуй-нед0х*ярим.Нихуя,недохуядохуярим-похуярили
True['д0х*ярим']To uncensor texts from a.tsvfile with anecdotes using default settings run the following command:python-mfuckstatsInstallationTo install frompip:pipinstallf-ckTo create environment and install all dependencies execute the following command:condaenvcreate-fenvironment.yml
Package: fck-aws-sso
A CLI tool to automate AWS SSO login. It uses selenium with chrome under the hood.1. Install withpipxpipx install fck-aws-sso2. Run first time with--no-headlessYou need that to save your browser user data.BROWSER=trueis hack so aws sso won't open browser. Browser will be opened byfck-aws-sso.BROWSER=true aws sso login | fck-aws-sso --no-headless3. Add to.bashrcor.zshrcBROWSER=true aws sso login | fck-aws-sso4. Forget that you ever had to login to AWS SSO manually.How it worksScript readsaws sso loginoutput from stdin and parses it. Then it opens chrome with user data dir and navigates to AWS SSO login page. After that it fills the form and submits it. Finally it waits for aws sso to confirm login and then it closes chrome. There is default headless mode so you won't see anything. If you want to see what's going on you can use--no-headlessoption. It will open chrome and you will see what's going on.PrerequisitesYou needgoogle-chromeinstalled and in yourPATH.
Package: fclist
###Python cffi bridge to fontconfig's FcFontList/FcFontMatchUseful for python programs that need to query information about fonts installedin the system(use this instead of parsing fc-list output). Requires thefontconfig shared library installed in a directory that the cffi module canfind.###Usage```pythonfrom fclist import fclist, fcmatch# Print the family, style and file path of monospace/truetype fontsfor font in fclist(spacing='mono', fontformat='TrueType'):print font.family, font.style, font.file# Print the system's default monospace fontprint fcmatch('monospace')````fclist` can receive any keyword arguments that can be passed to the `fc-list`command, and the returned font objects have most attributes defined byfontconfig.h.`fcmatch` receives the same pattern that is normally passed to `fc-match`, butit doesn't support the --all/--sort options(only returns a single font object).
Package: fclist-cffi
Python cffi bridge to fontconfig's FcFontList/FcFontMatchNote: this isa plublishedfork of tarrudapython-fclist.Useful for python programs that need to query information about fonts installed in the system(use this instead of parsing fc-list output).
Requires the fontconfig shared library installed in a directory that thecffi modulecan find.Installingpipinstallfclist-cffiUsagefromfclistimportfclist,fcmatch# Print the family, style and file path of monospace/truetype fontsforfontinfclist(spacing='mono',fontformat='TrueType'):printfont.family,font.style,font.file# Print the system's default monospace fontprintfcmatch('monospace')fclistcan receive any keyword arguments that can be passed to thefc-listcommand, and the returned font objects have most attributes defined by
fontconfig.h.fcmatchreceives the same pattern that is normally passed tofc-match, but
it doesn't support the --all/--sort options(only returns a single font object).TestsTests are written to usepytest.
Package: fclogr
fclogr(gotmax23/fclogr)(gotmax23/fclogr-dev)fclogr is a tool for managing RPM changelogs and updatesLinksfclogr project hubfclogr git.sr.ht repofclogr trackerfclogr mailing list(~gotmax/fclogr@lists.sr.ht)ContributingSeeCONTRIBUTING.md.LicenseThis repository is licensed underSPDX-License-Identifer: GPL-2.0-or-later
Package: fcm-adapter
FCM AdapterThis is a simple adapter for theFCM(Firebase Cloud Messaging) service.Installationpipinstallfcm_adapterpoetryaddfcm_adapterUsagefromfcm_adapterimportFCMAdapterimportjsonasyncdefmain(token:str):withopen('key.json')asf:key=json.load(f)fcm_adapter=FCMAdapter(key)awaitfcm_adapter.send_message({"token":token,"notification":{"title":"Hello World"},})FCMAdapter initializationParameterskey: dict- Google key. You can get it from theFirebase Console. Documentationhere.client: Union[httpx.AsyncClient, None] = None- httpx.AsyncClient instance. If not provided, a new instance will be created.send_message_url: Union[str, None] = None- FCM send message url. If not provided, the default value will be used.validate_only: bool = False- Flag for testing the request without actually delivering the message. Works only with thesend_messagemethod.sendSend a message to a device.
SeeFCM documentationfor more details.Parametersdata: dict- Data to send to FCM service.ReturnsResponse from FCM service. SeeFCM documentationfor more details.Examplefromfcm_adapterimportFCMAdapterasyncdefmain(fcm_adapter:FCMAdapter,token:str):response=awaitfcm_adapter.send({"validate_only":False,"message":{"token":token,"notification":{"title":"Hello World"},},})send_messageSend a message to a device. The function is a wrapper around thesendmethod,
but it expects to receive only inner message data.Iffcm_adapter.validate_onlyis set toTrue,
the request to FCM will be sent with"validate_only": true.Parametersmessage: dict- Message data to send to FCM service.ReturnsResponse from FCM service. SeeFCM documentationfor more details.Examplefromfcm_adapterimportFCMAdapterasyncdefmain(fcm_adapter:FCMAdapter,token:str):response=awaitfcm_adapter.send_message({"token":token,"notification":{"title":"Hello World"},})DevelopmentFirst, installpoetry.Then, install dependencies:poetryinstallFormattingpoetryrunblack.Testingpoetryrunpytest