Saravanan666/pypi-org huggingface dataset:
Package: scpca
scPCA - A probabilistic factor model for single-cell datascPCA is a versatile matrix factorisation framework designed to analyze single-cell data across diverse experimental designs.scPCA is a young project and breaking changes are to be expected.Quick installscPCA makes usetorch,pyroandanndata. We highly recommend to run scPCA on a GPU device.Via PypiThe easiest option to installscpcais via Pypi. Simply type$ pip install scpcainto your shell and hit enter.Free software: MIT licenseDocumentation:https://sagar87.github.io/scPCA/index.htmlCreditsHarald Vöhringer
Package: scpclient
A library that implements the client side of the scp (Secure Copy)
protocol. It is designed to be used with paramiko
(http://www.lag.net/paramiko/).Using paramikoThere are many ways to use paramiko. For the purposes of these
examples, you want to obtain an authenticated SSHClient object:import paramiko

ssh_client = paramiko.SSHClient()
ssh_client.connect(hostname, username=username, key_filename=key_filename, password=password)Writing filesThe scpclient.Write object is used to write files to an scp
server. Its required parameters are a paramiko.SSHClient instance and
a remote directory name. It has 2 methods: send_file and
send. send_file takes a filename to send, send takes a file-like
object, a remote filename, a mode, and a length. You may call send and
send_file multiple times.Example:with closing(Write(ssh_client.get_transport(), '.')) as scp:
    scp.send_file('file.txt', True)
    scp.send_file('../../test.log', remote_filename='baz.log')

    s = StringIO('this is a test')
    scp.send(s, 'test', '0601', len(s.getvalue()))Writing directoriesExample:with closing(WriteDir(ssh_client.get_transport(), 'subdir')) as scp:
    scp.send_dir('../../manuals', preserve_times=True, progress=progress)Reading filesExample:with closing(ReadDir(ssh_client.get_transport(), '.')) as scp:
    scp.receive_dir('foo', preserve_times=True)Reading directoriesExample:with closing(Read(ssh_client.get_transport(), '.')) as scp:
    scp.receive('file.txt')Change log0.7 2010-10-27 Eric V. SmithRemove hack for changing the RPM name (issue #10).No code changes.0.6 2016-10-02 Eric V. SmithFixed issue #8, Support building wheels.No code changes.0.5 2014-04-27 Eric V. SmithFixed issue #5, Not all files included in sdist.Fixed issue #6, Rename bdist RPM to python-scpclient.No code changes.0.4 2012-11-28 Eric V. SmithFixed issue #2, Missing contextlib import. Thanks Olivier CARRERE.0.3 2011-10-31 Eric V. SmithImproved documentation, including how to create a paramiko
connection.0.2 2011-10-31 Eric V. SmithRemoved useless tests.Fixed embarassing last minute typo which broke the code.Included trivial examples in README.txt. Needs much work.Forbid files that contain ‘..’ in the filename. This is an attempt
to prevent path traversal. This approach is simplistic, but it’s a
reasonable first step and gets the job done.0.1 2011-10-31 Eric V. SmithInitial release.
Package: scPECA
scPECAIntroductionThis is a python version of PECA2 gene regulatory
network construction software designed for single-cell data.
It has a faster running speed and a lower memory footprint.Installationpip install scPECAOr install via Githubgit clone https://github.com/zhangjiahao1234/scPECA.git
cd scPECA
python setup.py installRun scPECAInputscPECA requires to input the paired (sc)RNA-seq and (sc)ATAC-seq data,
and it provides data pre-processing in some formats.
(Pre-processing can also be done manually by the user)Format 1Paired bulk RNA-seq and ATAC-seq count datasample_name_RNA.txtgene110gene23sample_name_ATAC.txtchr1_10000_101001chr1_20000_201000Format 2scRNA-seq count data and scATAC-seq count data within the same cluster
without meta informationsample_name_scRNA.csvbarcode1barcode2gene1119gene236sample_name_scATAC.csvbarcode1barcode2chr1_10000_1010010chr1_20000_2010001Format 3scRNA-seq count data and scATAC-seq count data
with meta informationsample_name_scRNA.csvbarcode1barcode2gene1119gene236sample_name_scRNA_meta.csvbarcode1celltype1barcode2celltype2sample_name_scATAC.csvbarcode1barcode2chr1_10000_1010010chr1_20000_2010001sample_name_scATAC_meta.csvbarcode1celltype1barcode2celltype2Run exampleimport scPECA
import os

data_path = os.path.join(os.path.dirname(scPECA.__file__), 'Cones') # demo data path
demo = scPECA.scPECA(data_path, 'Cones', 'hg38') # Create a scPECA class
demo.RNA_process(2) # Format 2 RNA data processing
demo.ATAC_process(2) # Format 2 ATAC data processing
demo.network('Cones', 20, 0) # PECA2 GRN constructionThe details of each function can be viewed in python.Outputsample_name_network.txtSystem & Software RequirementsSystem: linuxLinux software: HomerPython package: pybedtools, ismember, scipy, numpy_groupies,ConsiderationsRNA data preprocessing currently supports only hg38 and mm10 genomes.pybedtools may not support the latest version of
python and will require the creation of a new environment.
Package: scPECA-test
scPECAIntroductionThis is a python version of PECA2 gene regulatory
network construction software designed for single-cell data.
It has a faster running speed and a lower memory footprint.Installationpip install scPECAOr install via Githubgit clone https://github.com/zhangjiahao1234/scPECA.git
cd scPECA
python setup.py installRun scPECAInputscPECA requires to input the paired (sc)RNA-seq and (sc)ATAC-seq data,
and it provides data pre-processing in some formats.
(Pre-processing can also be done manually by the user)Format 1Paired bulk RNA-seq and ATAC-seq count datasample_name_RNA.txtgene110gene23sample_name_ATAC.txtchr1_10000_101001chr1_20000_201000Format 2scRNA-seq count data and scATAC-seq count data within the same cluster
without meta informationsample_name_scRNA.csvbarcode1barcode2gene1119gene236sample_name_scATAC.csvbarcode1barcode2chr1_10000_1010010chr1_20000_2010001Format 3scRNA-seq count data and scATAC-seq count data
with meta informationsample_name_scRNA.csvbarcode1barcode2gene1119gene236sample_name_scRNA_meta.csvbarcode1celltype1barcode2celltype2sample_name_scATAC.csvbarcode1barcode2chr1_10000_1010010chr1_20000_2010001sample_name_scATAC_meta.csvbarcode1celltype1barcode2celltype2Run exampleimport scPECA
import os

data_path = os.path.join(os.path.dirname(scPECA.__file__), 'Cones') # demo data path
demo = scPECA.scPECA(data_path, 'Cones', 'hg38') # Create a scPECA class
demo.RNA_process(2) # Format 2 RNA data processing
demo.ATAC_process(2) # Format 2 ATAC data processing
demo.network('Cones', 20, 0) # PECA2 GRN constructionThe details of each function can be viewed in python.Outputsample_name_network.txtSystem & Software RequirementsSystem: linuxLinux software: HomerPython package: pybedtools, ismember, scipy, numpy_groupies,ConsiderationsRNA data preprocessing currently supports only hg38 and mm10 genomes.pybedtools may not support the latest version of
python and will require the creation of a new environment.
Package: sc-permut
sc_permutDeep learning annotation of cell-types with permutation inforced autoencoderSummaryParse Scanpy, Seurat and CellRanger objectsFast crawl through your folder and detect Seurat (.rds), Scanpy (.h5ad) or cellranger (.h5) atlas files.UsageThe one liner way to run checkatlas is the following:$cdyour_search_folder/
$python-msc_permut.#or$checkatlas.Or run it inside your python workflow.fromsc_permutimportsc_permutsc_permut.run(path,atlas_list,multithread,n_cpus)DevelopmentRead theCONTRIBUTING.mdfile.
Package: scperturb
scperturbA python package to compute E-distances in single-cell perturbation data and
perform E-tests.InstallJust install via pip:pip install scperturbUsage example# E-distances
estats = edist(adata, obs_key='perturbation')
# E-distances to a specific group (e.g. 'control')
estats_control = estats.loc['control']
# E-test for difference to control
df = etest(adata, obs_key='perturbation', obsm_key='X_pca', dist='sqeuclidean', control='control', alpha=0.05, runs=100)Check out notebooks --> e-distance for tutorial.
Package: sc.pfg.brazilianfields
Table of ContentsOverviewRequirementsInstallationUsing in a Plone SiteUninstallSponsoringCreditsChangelog1.1.1 (2012-08-01)1.1 (2012-07-24)1.0 (2011-12-21)0.8.1 (2011-01-17)0.8 (2009-11-17)0.7 (2009-11-14)0.6 (2009-07-09)0.5 (2009-06-02)OverviewA homage to Brazilian bureaucracy,sc.pfg.brazilianfieldsaims to provide
Brazil-specific fields for use withPloneFormGenRequirementsPlone 3.3.x / 4.0.x / 4.1.x (http://plone.org/products/plone)Products.PloneFormGen >= 1.5 (http://plone.org/products/ploneformgen)Products.BrFieldsAndWidgets >= 1.2 (https://github.com/collective/Products.BrFieldsAndWidgets)InstallationTo enable this product, on a buildout based installation:Edit your buildout.cfg and addsc.pfg.brazilianfieldsto the list of eggs to install[buildout]
...
eggs =
    sc.pfg.brazilianfieldsNoteSince Plone 3.3 is not is necessary to explictly inform
plone.recipe.zope2instance recipe to install the ZCML slugAfter updating the configuration you need to run the ‘’bin/buildout’’,
which will take care of updating your system.Using in a Plone SiteActivate itGo to the ‘Site Setup’ page in the Plone interface and click on the
‘Add/Remove Products’ link.Choose the productPloneFormGen: Brazilian Fields(check checkbox at its
left side) and click the ‘Activate’ button.UninstallGo to the ‘Site Setup’ page in the Plone interface and click on the
‘Add/Remove Products’ link.Choose the productPloneFormGen: Brazilian Fields, which should be underActivated add-ons, (check checkbox at its left side) and click the
‘Deactivate’ button.NoteYou may have to empty your browser cache and save your resource
registries in order to see the effects of the product installation.SponsoringDevelopment of this product was sponsored bySimples Consultoriacustomers, including (but not limited
to):Rede Brasil AtualEssencisEscola Sao PauloCreditsErico Andrei (erico at simplesconsultoria dot com dot br) - Packaging and
plumbing.Changelog1.1.1 (2012-08-01)Resolves issue #1 (Couldn’t install sc.pfg.brazilianfields)
[cleberjsantos]1.1 (2012-07-24)Require Products.BrFieldsAndWidgets >= 1.2 [ericof]1.0 (2011-12-21)PEP 8 [ericof]Add uninstall profile [ericof]Add plone.app.testing based tests [ericof]Moved from svn.plone.org to github.com/collective [ericof]0.8.1 (2011-01-17)Fix distribution [erico_andrei]0.8 (2009-11-17)Adding MANIFEST.in to make releaser works [erico_andrei]0.7 (2009-11-14)Adds dependencies [erico_andrei]0.6 (2009-07-09)Fixes an infinite recursion when adding a BrPhoneField
[erico_andrei]Adds our types to the allowed content inside a FieldsetFolder
[erico_andrei]Localization
[erico_andrei]0.5 (2009-06-02)PloneFormGen fields based on BrFieldsAndWidgets
[erico_andrei]Initial release
[erico_andrei]
Package: scpi
Newasyncioversion. Only for Python 3.6 and aboveSince all the other wrappers either require VISA binary or are not generic (and do not implement the device I need)Basic idea here is to make transport-independent command sender/parser and a device baseclass that implements the common SCPI commandsA device specific implementation can then add the device-specific commands.Pro tip for thos wishing to work on the codehttps://python-poetry.org/## UsageInstall the package to your virtualenv with poetry or from pipInstatiate a transport (for GPIB you will needGPIBDeviceTransportto be able to use the device helper class)InstatiateSCPIProtocolwith the transport (optional, see below)InstantiateSCPIDevicewith the protocol (or as a shorthand: with the transport directly)Use the asyncio eventloop to run the device methods (all of which are coroutines)Or if you’re just playing around in the REPL useAIOWrapperto hide the eventloop handling
for traditional non-concurrent approach.See the examples directory for more.TODOCheck Carrier-Detect for RS232 transportin the RS232 transport check getCD to make sure the device is present before doing anything.
CTS can also be checked even if hw flow control is not in use.Basically wait for it for X seconds and abort if not found
Package: scpidev
pyscpidevA python package to turn your device into an SCPI instrument.ConceptThis package intends to make it easy for developers to turn any device that
can run python(3) and has some kind of communication interface, e.g. serial or
Ethernet, into an SCPI instrument. SCPI commands look likeMEASure:VOLTage?
CONFigure[:VOLTage][:DC] [{<range>|AUTO|MIN|MAX|DEF}]Short Term PlanGet the basic stuff running...Mid Term PlanImplement some samples for RaspberryPi.Long Term PlanImplement a web application to be able to serve HTTP requests and show some
nice GUI.InstallationI intend to publish this package on PyPi. For now you need to download the
code and run the following command from the root directory.python3-mpipinstall-e.UsageimportscpidevFurther ReadsWikipediaThe SCPI specification
Package: scp-ingest-pipeline
scp-ingest-pipelineFile Ingest Pipeline for Single Cell PortalThe SCP Ingest Pipeline is an ETL pipeline for single-cell RNA-seq data.PrerequisitesPython 3.7+Google Cloud Platform projectSuitable service account (SA) and MongoDB VM in GCP. SA needs roles "Editor", "Genomics Pipelines Runner", and "Storage Object Admin". Broad Institute engineers: see instructionshere.SAMtools, if usingingest/make_toy_data.pyTabix, if usingingest/genomes/genomes_pipeline.pyInstallFetch the code, boot your virtualenv, install dependencies:git clone git@github.com:broadinstitute/scp-ingest-pipeline.git
cd scp-ingest-pipeline
python3 -m venv env --copies
source env/bin/activate
pip install -r requirements.txtTo useingest/make_toy_data.py:brew install samtoolsTo useingest/genomes/genomes_pipeline.py:brew install tabixNow get secrets from Vault to set environment variables needed to write to the database:export BROAD_USER="<username in your email address>"

export DATABASE_NAME="single_cell_portal_development"

vault login -method=github token=`~/bin/git-vault-token`

# Get username and password
vault read secret/kdux/scp/development/$BROAD_USER/mongo/user

export MONGODB_USERNAME="<username from Vault>"
export MONGODB_PASSWORD="<password from Vault>"

# Get external IP address for host
vault read secret/kdux/scp/development/$BROAD_USER/mongo/hostname

export DATABASE_HOST="<ip from Vault (omit brackets)>"If you are developing updates for Sentry logging, then set the DSN:vault read secret/kdux/scp/production/scp_config.json | grep SENTRY

export SENTRY_DSN="<Sentry DSN value from Vault>"Be sure tounset SENTRY_DSNwhen your updates are done, so development logs are not always sent to Sentry.Git hooksAfter installing Ingest Pipeline, add Git hooks to help ensure code quality:pre-commit install && pre-commit install -t pre-pushThe hooks will expect thatgit-secretshas been set up. If you are a Broad Institute employee who has not done this yet, please see:broadinstitute/single_cell_portal_configsfor specific guidance.Bypass hooksIn rare cases, you might need to skip Git hooks, like so:Skip commit hooks:git commit ... --no-verifySkip pre-push hooks:git push ... --no-verifyTestAfterinstalling:source env/bin/activate
cd tests

# Run all tests
pytestSome commonpytestusage examples (run in/tests):# Run all tests and see print() output
pytest -s

# Run only tests in test_ingest.py
pytest test_ingest.py

# Run all tests, show code coverage metrics
pytest --cov=../ingest/For more, seehttps://docs.pytest.org/en/stable/usage.html.UseRun this every time you start a new terminal to work on this project:source env/bin/activateSeeingest_pipeline.pyfor usage examples.
Package: scpi-pkg
SCPI_PKGThescpi_pkgpackage provides Python implementations of estimation and inference procedures for Synthetic Control methods.AuthorsMatias D. Cattaneo (cattaneo@princeton.edu)Yingjie Feng (fengyj@sem.tsinghua.edu.cn)Filippo Palomba (fpalomba@princeton.edu)Rocio Titiunik (titiunik@princeton.edu)Websitehttps://nppackages.github.io/scpi/InstallationTo install/update use pippip install scpi_pkgUsagefrom from scpi_pkg.scdata import scdata
from from scpi_pkg.scdataMulti import scdataMulti
from scpi_pkg.scest import scest
from scpi_pkg.scpi import scpi
from scpi_pkg.scplot import scplot
from scpi_pkg.scplotMulti import scplotMultiReplication:Germany reunification example.Dependenciescvxpy          (>= 1.1.18)dask            (>= 2021.04.0)ecos            (>= 2.0.7)luddite         (>= 1.0.2)numpy         (>= 1.20.1)pandas        (>= 1.5.0)plotnine       (>= 0.8.0)scikit-learn  (>= 0.24.1)scipy            (>= 1.7.1)statsmodels (>= 0.12.2)ReferencesFor overviews and introductions, seenppackages website.Software and ImplementationCattaneo, Feng, Palomba, and Titiunik (2022)scpi: Uncertainty Quantification for Synthetic Control Estimators.Technical and MethodologicalCattaneo, Feng, and Titiunik (2021):Prediction Intervals for Synthetic Control Methods.<br>Journal of the American Statistical Association.Cattaneo, Feng, Palomba, and Titiunik (2022): Uncertainty Quantification in Synthetic Controls with Staggered Treatment Adoption, working paper.<br><br>
Package: scplotlib
scplotlibscplotlib is a python plotting library for theSingleCellobject. It is based onmatplotlib. It can generate various plots for data stored in a SingleCell object such as:Visualizing high dimensional data - t-SNE plots, PCA plotsSpecialized plots - heatmaps, silhouette plots, outlier score plotsInstallationTo install scplotlib, run the following commandpip install scplotlibDocumentationCheck the project homepage for documentation.ContactContact the author oninfo@edwinvans.comto give feedback/suggestions for further improvements and to report issues.
Package: scpmanWechat
This is Send message to Wechat application package. You can useGithubpip install scpmanWechatdemofrom scpmanWechat import QYWeChatBot

CORPID = 'XXX'
CORPSECRET = 'XXXX'
AGENTID = '1000002'
Tag = "1"
msg = "hello world"
wx_bot = QYWeChatBot(CORPID, CORPSECRET, AGENTID, Tag)
wx_bot.send_msg_to_tag_group("xxx")
Package: scpper
scpperscpperis a Python wrapper forScpperDB API.InstallationOpen console and run the following command:pip install scpperDone.DocumentationDetailed information for developers can be found here:http://scpper.readthedocs.org/en/latest/.Bugs/RequestsPlease use theGitHub issue trackerto submit bugs or request features.AuthorMrNereof- creator of Scpper Python wrapper.FiftyNine- creator ofScpperDB.
Package: scpram
With the rapid advancement of single-cell sequencing technology, we are gradually enabled to delve into the cellular re-sponses to various external perturbations at the gene expression level. However, obtaining perturbed samples in certain scenarios may be considerably challenging, and the substantial costs associated with sequencing also curtail the feasibil-ity of large-scale experimentation. A repertoire of methodologies has been employed for forecasting perturbative re-sponses in single-cell gene expression. However, existing methods only focus on predictions at the average level and do not capture the heterogeneity at the single-cell resolution effectively. Here we present scPRAM, a method for predicting Perturbation Responses in single-cell gene expression based on At-tention Mechanisms. Leveraging variational autoencoders and optimal transport, scPRAM aligns cell states before and after perturbation, followed by accurate prediction of gene expression responses to perturbations for unseen cell types through attention mechanisms. Experiments on multiple real perturbation datasets involving drug treatments and bacteri-al infections demonstrate that scPRAM attains heightened accuracy in perturbation prediction across cell types, species, and individuals, surpassing existing methodologies. Furthermore, scPRAM demonstrates outstanding capability in identi-fying differentially expressed genes under perturbation, capturing heterogeneity in perturbation responses across spe-cies, and maintaining stability in the presence of data noise and sample size variations.
Package: scpreader
scp-readerRead the SCP wiki from the terminal!RequirementsYou need python 3.9 (I haven't tested with lower versions) and the packages inrequirements.txtInstallArchAvalible in the AURyay -S python-scpreaderOtherAvailible through pippip install --upgrade scpreaderExecutescp_readerCommandshelp            list of commands
r               random scp
<scp-number>    specified scp
save            save scp data to <scp-number>.txt
logout          quit the program
Package: scprel
Scprel - Single-Cell Data Preprocessing in PythonImport scprel as:import scprelThis package allows to perform basic preprocessing steps for single-cell analysis of multiple samples. It includes scrublets detection, quality control, normalization withtarget_sum=1e4, leiden clustering, annotation of cell types withPanglaoDBdatabase and infercnv calculations. It integrates some of theScanpy,Decoupler,InfercnvpyandAnndatafunctions. It is designed to facilitate workflow when analyzing multiple samples. Each sample is analyzed and annotated separately and then they are concatenatedExample of usage:scprel.scrun(names = ['sample1', 'sample2'], path = '/content/drive/MyDrive/MyDirectory/')'names' -list of sample names in your directory (.h5 format);'path' -path to the directory with samplesThe result of this function is theanndata.AnnDataobject, compressed withhdf5plugin, with concatenated samples, filtered by 'mt' and 'ribo' genes, with annotated gene locations and annotated tumor cells based on cnv score. All immune cells in the sample are considered reference cells for infercnv calculations.The resulting file will be saved in your default home directory and is ready for batch correction and further analysis.
Package: scprep
scprepprovides an all-in-one framework for loading, preprocessing, and plotting matrices in Python, with a focus on single-cell genomics.The philosophy ofscprep:Data shouldn’t be hidden in a complex and bespoke class object.scprepworks withnumpyarrays,pandasdata frames, andscipysparse matrices, all of which are popular data formats in Python and accepted as input to most common algorithms.Your analysis pipeline shouldn’t have to change based on data format. Changing from anumpyarray to apandasdata frame introduces endless technical differences (e.g. in indexing matrices).scprepprovides data-agnostic methods that work the same way on all formats.Simple analysis should mean simple code.scpreptakes care of annoying edge cases and sets nice defaults so you don’t have to.Using a framework shouldn’t be limiting. Because nothing is hidden from you, you have access to the power ofnumpy,scipy,pandasandmatplotlibjust as you would if you used them directly.Installationpreprocessing is available onpip. Install by running the following in a terminal:pip install --user scprepAlternatively, scprep can be installed usingConda(most easily obtained via theMiniconda Python distribution):conda install -c bioconda scprepQuick StartYou can usescprepwith your single cell data as follows:import scprep
# Load data
data_path = "~/mydata/my_10X_data"
data = scprep.io.load_10X(data_path)
# Remove empty columns and rows
data = scprep.filter.remove_empty_cells(data)
data = scprep.filter.remove_empty_genes(data)
# Filter by library size to remove background
scprep.plot.plot_library_size(data, cutoff=500)
data = scprep.filter.filter_library_size(data, cutoff=500)
# Filter by mitochondrial expression to remove dead cells
mt_genes = scprep.select.get_gene_set(data, starts_with="MT")
scprep.plot.plot_gene_set_expression(data, genes=mt_genes, percentile=90)
data = scprep.filter.filter_gene_set_expression(data, genes=mt_genes,
                                                percentile=90)
# Library size normalize
data = scprep.normalize.library_size_normalize(data)
# Square root transform
data = scprep.transform.sqrt(data)ExamplesScatter plotsJitter plotsHelpIf you have any questions or require assistance using scprep, please read the documentation athttps://scprep.readthedocs.io/or contact us athttps://krishnaswamylab.org/get-help