Saravanan666/pypi-org huggingface dataset:
Package: fastclone-guanlab
FastCloneFastClone is a fast algorithm to infer tumour heterogeneity. Given somatic
mutation frequencies and copy number data, FastClone infers subclonal
composition and phylogeny. The algorithm won the first place in DREAM Somatic
Mutation Calling -- Heterogeneity Challenge.InstallationFastClone needs Python 3.5 or later version. It needs logbook, python-fire,
scikit-learn, and pandas. To install the package using Pip,git clone https://github.com/GuanLab/FastClone_GuanLab.git
pip install FastClone_GuanLab/(Please make sure you have the slash at the end, which forces pip to install from local directory, otherwise it will run into error)You also can directly pip install FastClone with the command below.pip install fastclone-guanlabUsageFastClone accepts either MuTect VCF + Battenberg format (specified in the DREAM
SMC-Het Challenge) or PyClone format.The general format of command line for reading PyClone format files:fastclone load-pyclone prop [FILE_NAME] [TUMOR_PURITY] solve [OUTPUT_PATHWAY](If purity is unavailable, input "None" at the position of [TUMOUR__PURITY], and FastClone will infer purity automatically)A pseudo example to load samples from PyClone format files and infer (t1.tsv is included in this repository):fastclone load-pyclone prop t1.tsv 0.8 solve ./fastclone_result（Please make sure t1.tsv is under your current directory. Note this pseudo example only has one clone with a purity ~0.15）The general format of command line for reading VCF + Battenberg format files:fastclone load-mutect-battenberg prop [VCF_FILE_NAME] [TUMOR_/_NORMAL_COLUMN] [BATTENBERG_FILE_NAME] solve [OUTPUT_PATHWAY]A pseudo example to load samples from VCF + Battenberg files (VCF + Battenberg mode does not need tumor purity):fastclone load-mutect-battenberg prop 0009b464-b376-4fbc-8a56-da538269a02f tumor 0009b464-b376-4fbc-8a56-da538269a02f.consensus.20170119.somatic.cna.txt solve ./fastclone_result(Example files are in the folder called Battenberg_VCF_sample)Runfastclonefor more help information.If MuTect VCF and PyClone samples are provided, note that MuTect
mutations are labelled as 'Chromosome:Coordinate:AltBase', such as
'Y:15989697:G'. Make sure PyClone ID uses the same ID.Separately, subclone.py will infer purity (whether a starter value is given or not), and subclone identification and assignment; phylogeny.py will infer phylogeny.Output1.subclones.csv gives proportion of each clone in a tumor sample.2.scores.csv gives SNPs assignment. Each column corresponding to a clone, and the entries in each column indicates how likely the SNP is assigned to the clone.3.phylogeny.png shows the tree structure of clones.4.phylogeny_proportion.csv gives the proportion of a subclone in its parent clone.(We named clones with numeric values, which starts from 0, and the names are consistent within all output files)Versions1.0.9Fix the phlogeny module, and add a new function to output the proportion of a subclone in its parent clone.
Package: fastcluster
This library provides Python functions for hierarchical clustering. It
generates hierarchical clusters from distance matrices or from vector data.This module is intended to replace the functionslinkage, single, complete, average, weighted, centroid, median, wardin the modulescipy.cluster.hierarchywith the same
functionality but much faster algorithms. Moreover, the functionlinkage_vectorprovides memory-efficient clustering for vector data.The interface is very similar to MATLAB's Statistics Toolbox API to make code
easier to port from MATLAB to Python/NumPy. The core implementation of this
library is in C++ for efficiency.User manual:fastcluster.pdf.The “Yule” distance function changed in fastcluster version 1.2.0. This is
following achange in SciPy 1.6.3.
It is recommended to use fastcluster version 1.1.x together with SciPy versions
before 1.6.3 and fastcluster 1.2.x with SciPy ≥1.6.3.The fastcluster package is considered stable and will undergo few changes
from now on. If some years from now there have not been any updates, this does
not necessarily mean that the package is unmaintained but maybe it just was
not necessary to correct anything. Of course, please still report potential
bugs and incompatibilities todaniel@danifold.net. You may also usemy GitHub repositoryfor bug reports, pull requests etc.Note thatPyPIandmy GitHub
repositoryhost the source code
for the Python interface only. The archive with both the R and the Python
interface is available onCRANand the GitHub repository“cran/fastcluster”. Even though I appear
as the author also of this second GitHub repository, this is just an automatic,
read-only mirror of the CRAN archive, so please do not attempt to report bugs or
contact me via this repository.Installation files for Windows are provided onPyPIand onChristoph Gohlke's web
page.Christoph Dalitz wrote a pureC++ interface to fastcluster.Reference: Daniel Müllner,fastcluster: Fast Hierarchical, Agglomerative
Clustering Routines for R and Python, Journal of Statistical Software,53(2013), no. 9, 1–18,https://doi.org/10.18637/jss.v053.i09.
Package: fast-coco-eval
Fast-COCO-EvalThis package wraps a facebook C++ implementation of COCO-eval operations found in thepycocotoolspackage.
This implementation greatly speeds up the evaluation time
for coco's AP metrics, especially when dealing with a high number of instances in an image.ComparisonFor our use case with a test dataset of 1500 images that contains up to 2000 instances per image we saw up to a 100x faster
evaluation using fast-coco-eval (FCE) compared to the original pycocotools code.Seg eval pycocotools 4 hours 
Seg eval FCE: 2.5 min

BBox eval pycocotools: 4 hours 
BBox eval FCE: 2 minGetting startedInstallpipinstallfast-coco-evalIf you clone the repo and install it locally, the following command is recommendedpipinstall-e.given that you are in the fast-coco-eval directory. There seem to be anissuewith
loading the C++ extensions when installing it from the root directory without the -e flag.UsageThis package contains a faster implementation of thepycocotoolsCOCOEvalclass.
Due to torch being used to compile and access the C++ code, it needs to be imported before using the package.
To import and useCOCOeval_fasttype:importtorchfromfast_coco_evalimportCOCOeval_fastFor usage, look at the originalCOCOEvalclass documentation.Dependenciespytorch>=1.5pycocotoolspybind11numpyIt would be nice to decouple it from the pytorch build tool for the
c++ compilation.TODOsWrap c++ codeGet it to compileAdd COCOEval class wraperRemove detectron2 dependenciesCheck if it works on windowsRemove torch dependenciesLicenseDistributed under the apache version 2.0 license, seelicensefor more information.
© 2021 Sartorius AG
Package: fast-coco-eval-python
# Introduction
A fast coco eval api that wraps facebook’s coco eval api in detectron2# Reference
The code filecocoeval.cppin foldercocoevalis referenced from repositoryhttps://github.com/facebookresearch/detectron2.
The corresponding commit id is 3e71a2711bec4eaa488d29cd07f124d384d9d69e ‘Apply clang-format update fixes’.The code filecocoeval.hin folder ‘cocoeval` is referenced from repositoryhttps://github.com/facebookresearch/detectron2.
The corresponding commit id is 60d7a1fd33cc48e58968659cd3301f3300b2786b ‘update copyright header’.The pythonfast_coco_eval_api.pyis modified fromhttps://github.com/Megvii-BaseDetection/YOLOX/blob/main/yolox/layers/fast_coco_eval_api.py.
The corresponding commit id is 6513f769fa500b3c7ad23b90a91dcbd8402be330 ‘feat(layers): support jit op’.
Package: fast-cody
Fast Complementary Dynamics CodeWe're currently working on a pip installation, but for now, this is how you can get started with our codebase.Clone this repo and all its submodules:git clone --recursive https://github.com/otmanon/fast_cd_pybInside the repository above, install the dependencies:pip install -r requirements.txtFinally, build the library from source by running:python setup.py installAppsWe provide a variety of fast_cd apps shown in our paper.Interactive Affine HandleRunimport fast_cd_pyb as fcd
fcd.apps.interactive_cd_affine_handle()This should run a few computations, and then finally open a window with the
classic Complementary Dynamics fish. By playing with the Guizmo, you can interact with
the fish. Pressgto change guizmo transorm operations.We also provide a few different meshes. The demo found indemos/affine_handle.pyshows how to change some of the inputs we
give to theinteractive_cd_affine_handlesuch as changing the subspace size, reading from cache,
or using different meshes.We also provide many example meshes in thedatadirectory. To run the demo on a.mshfile of your choice, runfcd.apps.interactive_cd_affine_handle(msh_file_path)
Package: fast-colorthief
Fast colorthiefA Python module for selecting most dominant colors in the image. Based onhttps://github.com/fengsp/color-thief-pybut faster.InstallationLinux, MacOS 10.15 or newer:pip install fast_colorthiefOther operating systems (CMakerequired):git clone https://github.com/bedapisl/fast-colorthief
cd fast-colorthief
git submodule update --init --recursive
pip3 install .Exampleimport fast_colorthief

image_path = 'image.jpg'

dominant_color = fast_colorthief.get_dominant_color(image_path)
color_palette = fast_colorthief.get_palette(image_path)Benchmark1200 x 1200 jpg imageAlgorithmTime per imageFast colorthief (input numpy array)0.0012sFast colorthief (input filename)0.034sReference (https://github.com/fengsp/color-thief-py) (input filename)0.509sHow does it workBackend is written in C++ for better performance.Uses Modified Median Cut Quantization algorithm.
Package: fastcom-cli
Fast.com CLIUnofficial CLI tool to run Internet speed measurement tests using Fast.com's
service.Installationpipinstall--userfastcom-cliUsagefastcom [-h] [-q] [-i ITERATIONS] [-s SERVERS] [-j] [-r TRIM] [-t TIMEOUT] [-v]

A CLI tool to test your Internet speed using Fast.com.

options:
  -h, --help            show this help message and exit
  -q, --quiet           Suppresses progress output (default: False)
  -i ITERATIONS, --iterations ITERATIONS
                        Controls the number of loops (default: 10)
  -s SERVERS, --servers SERVERS
                        Controls the number of servers to test against during
                        each loop (default: 5)
  -j, --json            Outputs a JSON formatted summary (implies --quiet)
                        (default: False)
  -r TRIM, --trim TRIM  Controls the percentage of results to trim from the top
                        and bottom of the results for the "Mean (trimmed)" value
                        (default: 10)
  -t TIMEOUT, --timeout TIMEOUT
                        Controls the number of seconds to wait before stopping
                        all tests (default: 60)
  -v, --version         show program's version number and exitSimply runfastcomfor the default usage.$ fastcom

Count: 1/50
Loop: 1/10
Unique servers: 1
Median: 796.40 Mbps
Mean: 796.40 Mbps
Mean (trimmed): 796.40 Mbps
Max: 796.40 Mbps
Last: 796.40 Mbps
----------------------------
...
Max speed: 822.98 Mbps
Mean speed: 574.89 Mbps$ fastcom --json

{
  "count": 50,
  "unique_servers": 39,
  "median": 72451737.42476499,
  "mean": "559.08 Mbps",
  "mean_trimmed": "567.41 Mbps",
  "max": 107790185.14579706,
  "last": 36975053.209750414
}
Package: fastconf
FastConfSimple lib for configurationInstall$ pip install fastconfExample project structuremain.py
core/
    __init__.py
    config.pymain.pyfromcoreimportconfigprint('TOKEN:',config.TOKEN)core/config.pyimportfastconfTOKEN='...'fastconf.config(__name__)Run project:$ python main.py
TOKEN: ...Theconfig.ymlfile is created in the project root directory.Change him:TOKEN: 'MY_TOKEN'Run again$ python main.py
TOKEN: MY_TOKENfastconf.config(name, file='config.yml', root=ROOT_DIR)name- current name of config modulefile- name config filedir- path to config dir
Package: fastconfig
fastconfigA lightweight way to find the project root and load config in python3.
current support is [3.9,3.10,3.11].This library provides two functionalities:A function to search for files while traversing up to the project root.fastconfig.find_project_rootfastconfig.is_project_rootfastconfig.searchA function to directly build a class from a configuration file.fastconfig.config.FastConfigbuildto_dictInstallpipinstallfastconfigUsageexample.json{"setting_path":"setting_path","section":{"numeric":42}}other.tomlsetting_path="setting_path"[section]numeric=24# main.pyimportfastconfigfromfastconfig.configimportFastConfig,fc_fieldfromfastconfig.exceptionimportFastConfigErrorfromdataclassesimportfield,dataclass@dataclassclassConfig(FastConfig):result:int=fc_field(key="section.numeric",default=-1)# If metadata does not exist, it is searched by variable namesetting_path:str=fc_field(default="default")# Type checking is done based on the type of dataclass. Type checking is recursive.dic:dict[str,int]=fc_field(key="section",default_factory=dict)ifpath:=fastconfig.search("example.json"):try:# build instanceconfig=Config.build(path)assertconfig==Config(result=42,setting_path="setting_path",dic={"numeric":42})exceptFastConfigError:raiseRuntimeErrorelse:config=Config()ifother_path:=fastconfig.search("other.toml"):# can update configconfig=Config.build(other_path,config)assertconfig==Config(result=24,setting_path="setting_path",dic={"numeric":24})MotivationIn many projects, it is common to write configuration files, read them in code, and build Config classes. I created this library to enable these functions to be implemented by simply defining a class and specifying a file name (such as pyproject.toml).ContributionIf you have suggestions for features or improvements to the code, please feel free to create an issue first.
Package: fastcons
fastconsFastcons is a Python extension module that aims to provide an efficient implementation of cons.The fastcons module provides two types:nilandcons. Theniltype represents the empty list, while the cons type represents a pair - an immutable cell containing two elements.Currently requires Python 3.11, and Linux or MacOS.InstallationUsagePattern matchingAPI ReferenceLicenseInstallationYou can install fastcons using pip:pipinstallfastconsUsageThe fastcons module provides two types:nil: represents the empty list; andcons: represents a pair.You can create thenilobject by callingnil().You can create aconsobject by callingcons(head, tail).conscan be used to create linked lists: a chain ofconsobjects is considered a list if it is terminated bynil(), e.g.cons(1, cons(2, cons(3, nil()))).You can efficiently createconslists from Python sequences using thecons.from_xsmethod, wherexsis a sequence.fromfastconsimportcons,nil# Create a cons list using the cons functionxs=cons(1,cons(2,cons(3,nil())))# Create a cons list from a Python sequenceys=cons.from_xs([1,2,3])# Access the head and tail of a cons listassertxs.head==1assertxs.tail.head==2# Test for equalityassertxs==ysTheconsobjects are printed using Lisp-style notation, which makes it easier to read long lists.>>> cons.from_xs(range(1, 4))
(1 2 3)
>>> cons("foo", "bar")
('foo' . 'bar')
>>> cons(cons(1, 2), cons(cons(3, 4), nil()))
((1 . 2) (3 . 4))cons.liftcan be used to recursively transform dicts, lists, tuples and generators toconsobjects. dicts will be transformed to cons lists of pairs (association lists or alists), the rest will be transformed to alists.>>> cons.lift({'a': 2, 'b': 3})
(('a' . 2) ('b' . 3))
>>> cons.lift((1, 2, 3))
(1 2 3)
>>> cons.lift(x for x in ('a', 'b', 'c'))
('a' 'b' 'c')
>>> cons.lift({x: {x: y}} for x, y in zip(['a', 'b', 'c'], range(1, 4)))
((('a' ('a' . 1))) (('b' ('b' . 2))) (('c' ('c' . 3))))Pattern matchingPEP 622 pattern matching is supported forconsandnil:>>> match nil():
...   case nil():
...     print(nil())
...
nil()
>>> match cons(1, nil()):
...   case cons(a, d):
...     print(f"{a = }, {d = }")
...
a = 1, d = nil()API Referencenil()Returns the singletonnilobject. Thenilobject is falsy.cons(head, tail)Returns aconsobject with the givenheadandtail.cons.from_xs(xs)Returns aconsobject created from the Python sequencexs.cons.lift(xs)Recursively create aconsstructure by converting:lists, tuples, and generators toconslists; anddicts toconslists of pairs (association lists).assoc(object, alist)Find the first pair inalistwhose car is equal toobject, and return that pair. If no pair is found, oralistisnil(), returnnil().assp(predicate, alist)Return the first pair in alist for which the result of calling 'predicate' on its car is truthy. 'predicate' will be called with a single positional argument.Licensefastconsis released under the MIT license.
Package: fastcookie
fastcookie介绍cookie工具包软件架构软件架构说明安装教程pip安装pipinstallfastcookiepip安装（使用淘宝镜像加速）pipinstallfastcookie-ihttps://mirrors.aliyun.com/pypi/simple使用说明demoimportfastcookieimportrequeststest_res=fastcookie.get_requests_cookie(cookie_jar=requests.session().cookies)
Package: fastcopilot
FastCopilotExamplefromfastcopilotimportCopilotcopilot=Copilot(api_key="your-api-key")whileTrue:ipt=input("Me: ")reply=copilot.run(ipt.strip())print(reply)For asyncioimportasynciofromfastcopilotimportCopilotcopilot=Copilot(api_key="your-api-key")defmain():whileTrue:ipt=input("Me: ")reply=awaitcopilot.arun(ipt.strip())print(reply)if__name__=='__main__':asyncio.run(main())
Package: fastcopy
FastCopy基于 SSH 协议的多线程文件传输工具。目标是用来替换scp和rsync。特点文件切块处理，并行传输，速度更快支持使用文件名通配符及正则表达式来匹配需要传输的文件自动跳过本地与远程相同内容的文件自动保持发送端与接收端文件权限完全相同支持 SSH Config支持 SSH AgentTODO断点续传支持改进配置管理方式握手时确认会话参数，取消全局变量方式版本前后兼容编写测试用例保持软链接安装使用前须在服务器和本地同时安装本程序。pipinstallfastcopy使用服务器运行前首先确保服务端的 7523 端口未被占用fcpd-d本地下载fcpuser@host:/foo/bar./上传fcp./fake/fileuser@host:/foo/bar报文设计所有数据包均采用大端字节序1. 报文统一格式flagchksumlengthpayload1 Bytes4 Bytes2 Bytes...2. 报文类型推送申请:0x1拉取申请:0x2建立会话:0x3后续连接:0x4传输模式:0x5目录信息:0x6文件信息:0x7文件数量:0x8文件就绪:0x9数据传输:0xa传输完成:0xb异常退出:0xc3. 报文详情数据请求连接建立后，客户端首先需要向服务器申请拉取或推送，并将目的路径传给服务器拉取、推送的标识由flag字段决定方向: Client -> ServerPayload 格式为:connection infojson string建立会话服务器收到第一步的申请后，会产生一个 SessionID，并回传给客户端，客户端需要在自己本地保存方向: Server -> ClientPayload 格式为:session_id16 Bytes后续连接客户端后续与服务器建立的并发连接，第一个报文须告诉服务器 SessionID方向: Client -> ServerPayload 格式为:session_id16 Bytes文件总量连接就绪后，发送端需告知接收端文件总量Payload 长度 4 字节，所以最大允许传输文件数量为 4,294,967,296方向: Sender -> ReceiverPayload 格式:n_files4 Bytes文件信息文件发送发需将每一个文件的信息告知接收端。
包括文件的编号、权限、大小、创建时间、修改时间、访问时间、校验和、路径。
其中路径为相对路径。方向: Sender -> ReceiverPayload 格式:file_idpermsizemtimechksumpath4 Bytes2 Bytes8 Bytes8 Bytes16 Bytes...接收端文件准备就绪接收端收到文件信息后，需将文件信息记录起来，并在本地创建同样大小的空文件方向: Receiver -> SenderPayload 格式:file_id4 Bytes文件数据块传输报文Chunk Sequence 占用 4 字节，所以支持的单个文件最大为: 4 GB * ChunkSize方向: Sender -> ReceiverPayload 格式:file_idseqdata4 Bytes4 Bytes...4. 握手过程序号客户端服务器1客户端启动服务端启动2等待客户端连接3发起连接请求4接收客户端连接5等待客户端请求 (请求超时则断开)6发送PUSH或PULL请求7产生 SessionID8将 SessionID 传回客户端9接收 SessionID 并保存10循环创建多个并行连接11新连接携带 SessionID 逐一发送ATTACH请求12确认 SessionID 无误13将新连接添加至对应 Session 的连接池
Package: fastcore
Welcome to fastcorePython is a powerful, dynamic language. Rather than bake everything into
the language, it lets the programmer customize it to make it work for
them.fastcoreuses this flexibility to add to Python features
inspired by other languages we’ve loved, like multiple dispatch from
Julia, mixins from Ruby, and currying, binding, and more from Haskell.
It also adds some “missing features” and clean up some rough edges in
the Python standard library, such as simplifying parallel processing,
and bringing ideas from NumPy over to Python’slisttype.Getting startedTo install fastcore run:conda install fastcore -c fastai(if you use
Anaconda, which we recommend) orpip install fastcore. For aneditable
install,
clone this repo and run:pip install -e ".[dev]". fastcore is tested
to work on Ubuntu, macOS and Windows (versions tested are those show
with the-latestsuffixhere.fastcorecontains many features, including:fastcore.test: Simple testing functionsfastcore.foundation: Mixins, delegation, composition, and morefastcore.xtras: Utility functions to help with functional-style
programming, parallel processing, and morefastcore.dispatch: Multiple dispatch methodsfastcore.transform: Pipelines of composed partially reversible
transformationsTo get started, we recommend you read throughthe fastcore
tour.ContributingAfter you clone this repository, please runnbdev_install_hooksin
your terminal. This sets up git hooks, which clean up the notebooks to
remove the extraneous stuff stored in the notebooks (e.g. which cells
you ran) which causes unnecessary merge conflicts.To run the tests in parallel, launchnbdev_test.Before submitting a PR, check that the local library and notebooks
match.If you made a change to the notebooks in one of the exported cells,
you can export it to the library withnbdev_prepare.If you made a change to the library, you can export it back to the
notebooks withnbdev_update.
Package: fastcountvectorizer
FastCountVectorizerFastCountVectorizer is a faster alternative toscikit-learn'sCountVectorizer.Installationpip install fastcountvectorizerDocumentationSeefull documentation.LicenseCopyright (c) 2020 Santiago M. MolaFastCountVectorizer is released under theMIT License.The following files are included from or derived from third party projects:fastcountvectorizer.pyis derived from scikit-learn'sscikit-learn/sklearn/feature_extraction/text.py, licensed under a 3-clause BSD license. The original list of authors and license text can be found in the file header._csr.his derived from scipy'sscipy/sparse/sparsetools/csr.h, licensed under a 3-clause BSD license. The original list of authors and license text can be found in the file header.fastcountvectorizer/thirdparty/tslincludes thetsl::sparse_mapproject, released under the MIT License.fastcountvectorizer/thirdpartyincludes thexxHashproject, released under a BSD-2 Clause license.