Saravanan666/pypi-org huggingface dataset:
Package: sc.kupu.objectsupport
sc.kupu.objectsupportOverviewA product that enables external Flash content inside Kupu..RequirementsKupu 1.4.x (http://plone.org/products/kupu)Plone 3.1.x (http://plone.org/products/plone)InstallationTo enable this product,on a buildout based installation:Edit your buildout.cfg and addsc.kupu.objectsupportto the list of eggs to install[buildout]
...
eggs =
    sc.kupu.objectsupportTell the plone.recipe.zope2instance recipe to install a ZCML slug:[instance]
...
zcml =
    ...
    sc.kupu.objectsupportIf another package depends on the sc.kupu.objectsupport egg or
includes its zcml directly you do not need to specify anything in the
buildout configuration: buildout will detect this automatically.After updating the configuration you need to run the ‘’bin/buildout’’,
which will take care of updating your system.Go to the ‘Site Setup’ page in the Plone interface and click on the
‘Add/Remove Products’ link.Choose the product (check its checkbox) and click the ‘Install’ button.Uninstall – This can be done from the same management screen, but only
if you installed it from the quick installer.Note: You 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 AtualPortal da LoterofiliaDireitos da CriancaCreditsErico Andrei (erico at simplesconsultoria dot com dot br) - Packaging and
plumbing.Changelog1.0 (2009-05-31)Object, Param and Embed tags are removed from nasty tags
[erico_andrei]Enables Embed Tab in Kupu toolbar
[erico_andrei]Initial release
Package: sclass
# sclassSimple module that allows you to create classes with the concept of Private and Public attributes and methods.Just create your own class inheriting fromsclass.
Private methods are recognized by the first character of the attribute being‘_’`
from sclass import sclassclass Test(sclass):def __init__(self):self.name = “lorenzo”
self._surname = “bartolini”def publicmethod(self):return ‘Public’def _privatemethod(self):return ‘private’x = Test()print(x.name)
print(x.publicmethod())
print(x._surname)
print(x._privatemethod())
`Last two instructions will raise a custom exception:PrivateException
Package: sclbl
The sclbl CLI tools.Main usage:$sclblupload-ffile.onnx-n"Model name"The package exposes the following commands:upload: Upload an onnx file to the Scaailable Platform. Options:update: Update an existing model using its cfidmodels: List all models associated with the current user IDdevices: List all registered devices associated with the current user IDassignments: List all assignments associated with the current user IDassign: Create a new assignmentdelete: Delete a model, assignment, or id.Each of the commands above requires logging in to the Scailable platform using a valid username and
password combination. Seewww.scailable.netfor details. Upon first login, you will be asked to store your
username and password locally. You can remove the stored local details using:sclbl reset: Reset you user details.Seesclbl command --helpfor additional information and the required arguments/options.Note that the sclbl CLI depends on thesclblpypackage. Seehttps://pypi.org/project/sclblpy/for details.
The CLI needs at least version 0.1.6 of thesclblpypackage to work.
If you would like to upload fittedsklearnmodels, please use thesclblpypackage directly from python.
Package: sclblonnx
sclblonnxThesclblonnxpackage provides a high level API to construct and alter ONNX graphs.The basic usage is as follows:importsclblonnxassog=so.empty_graph()n1=so.node('Add',inputs=['x1','x2'],outputs=['sum'])g=so.add_node(g,n1)# etc.Please see theexamples/folder in this repo for examples.
Package: sc-libra
LIBRA - Machine Translation between paired
Single-Cell Multi-Omics DataSummaryLIBRA is a scalable toolkit for AI-Single-Cell data integration and prediction. It includes loading, clustering and visualization for either tasks. The Python-based implementation efficiently deals with big datasets as well as reduce the time requirements for multiple grid-base model trainings using parallelization.Discuss usage on theGithub. Read thedocumentation.For further details, please refer to theonline manuscriptcurrently at biorxiv repository (will be updated asap). If LIBRA is useful for your research, consider citing us.
Package: sclkme
scLKMEA Landmark-based Approach for Generating Multi-cellular Sample Embeddings from Single-cell DataIntroductionscLKME is a computational approach designed for generating sample embeddings in multi-sample single-cell data. scLKME models samples as cell distributions, and leverages lanbmark-based kernel mean embedding to generate a sample-by-landmark kernel matrix as sample embeddings. The workflow of scLKME is as follows:InstallationscLKME requirespythonversion >= 3.8, < 3.11.scLKMEincluding its dependencies can be installed via PyPI by running:pipinstallsclkmeDataAll the datasets used in this study are shared via.h5adformat. The datasets are available at:Multi-species:herePreterm:hereMyocardial Infarction:hereGet startedscLKME's apis are designed to be compatible with thescanpy's ecosystem. To usescLKME, here is a basic example:importsclkmeimportscanpyasscn_sketch=128sample_id="sample_id"adata=sc.read_h5ad("path_to_h5ad_data")sclkme.tl.sketch(adata,n_sketch=n_sketch)X_anchor=adata[adata.obs['sketch']].X.copy()sclkme.tl.kernel_mean_embedding(adata,partition_key="sample_id",X_anchor=X_anchor)# sample_embeddingadata.uns['kme'][f'{sample_id}_kme']For more details, examples and tutorials, check ourdocument.Run on a cloud platformTutorialsColabCell SketchingLandmark-based multi-sample single-cell data analysisCitationTBD
Package: scln-client
SOAR Communication Library New ClientProcedures for SOAR TCS and some other instruments communications.This library implements a TCP/IP socket following the SOAR standard messaging protocol, this is 4 bytes to define the message length followed by the message itself using a big-endian and ASCII coding.The command protocol is client/server with immediate response. A response should never take longer than 1500 mS.Install packagepipinstallscln-clientGetting startedThe package contains two classes SclnClient and SclnClientErrorSclnClientIt should be used to instantiate the scln client, it uses the following parameters:host: The hostname or IP address of the server (required)port: The port to connect (required)timeout: The time to wait for a response from the server before giving upmax_tx_retries: The number of times to try sending a command before giving up, default to 12 (optional)max_rx_retries: The number of times to try to reconnect while receiving a message before giving up, defaults to 3 (optional)max_reconnect_attempts: The number of times it will try to reconnect to the socket, if set to -1 it will try forevermax_reconnect_on_message: The number of times it will try to reconnect to the socket if disconnect in middle of a messageon_change: a function that will be called when the connection status changesconnect_on_create: The flag to decide if connect on instantiationSclnClientErrorAll raised errors in SclnClient object will be of type SclnClientError, then it should be imported to handle this exception type.Importing the packageExample codefromscln_clientimportSclnClient,SclnClientErrorscln=SclnClient("111.111.111.111",1111)resp=scln.send_command("SOME COMMAND")print(resp)
Package: sclog
sclog - simple colorized logRationalePython has a pretty convenientlogging framework built-in, which makes it super easy to get started:importlogginglogging.warning("That was easy")Or, if you have a few different files in your project and want to distinguish between them:importlogginglogger=logging.getLogger(__name__)logger.error("Uh oh, something bad happened")But, there are a few annoyances.First, asthe documentation explains,debug and info messages aren't shown with the default log level.
Want to add a quicklogging.debugmessage to your scripts? You'll need to configure a log formatter first.Second, thedefault log formatting is missing some information like the timestamp.
The default output looks something like this:WARNING:root:your warning message...and if you want it to look differently, you again need a custom formatter.This libraryThis library exists, to be honest, for my own convenience. Its purpose it to provide some useful (to me) defaults as averylight-weight layer on top of Python's default logging framework.
Specifically, it:Sets the default log level toDEBUGUses a formatter that includes the timestamp(Optionally) colorizes the output usingcolorlog(another task that normally requires creating a custom formatter)UsageThe "API" for this library is meant to be maximally compatible with the built-in logging API.
Like Python'sloggingmodule, it exposes agetLoggerfunction that you call with a string (the name).
This returns astandard Logger objectthat you use in a familiar way.fromsclogimportgetLoggerlogger=getLogger(__name__)logger.info("Hello,%s!","world")This outputs (in a nice green color):2021-01-01 00:00:00:00,000 - __main__ - DEBUG - Hello, world!Installationpip install sclog
pip install colorlog  # optional, include if you want colorsYou can also just copythe fileinto your own project.
Package: sclogger
[![Build Status](https://travis-ci.org/Kit-Scribe/sclogger.svg?branch=master)](https://travis-ci.org/Kit-Scribe/sclogger)# Simple colorized loggerCurrent version is: ‘v1.1.41’To install use:pip3 install –upgrade scloggerFind docs in the [docs](/docs) folder.Find code examples in the [examples](/docs/examples) folder.<h2>Print example</h2>![](/docs/images/sclogger.png)
Package: sclogging
scloggingA Python module (with the help of coloredlogs) to add color to logs.Still working on docs.Current docsget_logger is where to get started.Some options allow certain customizations in the records themselves (e.g. %f.red%something%f%) sets the FORE color for that word then returns to default color of that level of logging.Other options:
Colored spacerEasily setting seperate options for stderr and file logsCustom timer classAllows this:var_a = Timer(level="INFO")
             var_a.start_timer(Note="I started it")Log record:
time spacer var_a.module.function.start_timer INFO I started itWraps logging, colorama.BACK, FORE, CURSOR
Package: scltnn
scLTNN (single cell latent time neuron network)A composite regression neural network for latent timing prediction of single-cell RNA-seq dataFor more details, please check out ourpublication.Directory structure.
├── scltnn                  # Main Python package
├── experiments             # Experiments and case studies
├── scltnn                  # the raw code of scltnn
├── model                   # the pre-model by ANN
├── source                  # Documentation files
├── LICENSE
└── README.mdInstallationThescLTNNpackage can be installed via pip:pip install scltnnUsagePlease checkout the documentations and tutorials atscltnn.readthedocs.io.Reproduce resultsFollow instructions indatato prepare the necessary data, it can be download athttps://figshare.com/articles/dataset/scltnn_data/20383416Follow instructions inexperimentsfor case studiesContactZehua Zeng (starlitnightly@163.com)
Package: scludam
SCLUDAM (StarCLUsterDetectionAndMembership estimation)SCLUDAM(StarCLUsterDetectionAndMembership estimation) is a Python package for GAIA cataloguesdata fetching,star cluster detectionandstar cluster membership estimation.Repository and issueshttps://github.com/simonpedrogonzalez/scludamAuthorsSimón Pedro González.
Email:simon.pedro.g@gmail.comFeaturesIncluded modules and features are:fetcher: Query builder for easy access to GAIA catalogues data, functions to get catalogues and SIMBAD objects information.stat_tests: Set of three clusterability tests that can be used to detect the presence of a cluster in a sample.synthetic: Classes that can be used to generate synthetic astrometric samples by specifying the distributions and parameter values.detection: Detection of star clusters in a sample using an improved version of the Star Counts algorithm.shdbscan: Soft clustering based on theHDBSCANalgorithm.hkde: Kernel density estimation with per-observation or per-dimension variable bandwidth.membership: Membership probability estimation based onhkdesmoothing.pipeline: Pipeline for the detection and membership estimation, with default values and convenience functions.plots: Plot detection and membership estimation results alongside SIMBAD objects for better result interpretation.RequirementsPython 3.7.6+andR 3.6.3+are needed to run SCLUDAM. It is recommended to install scludam in a separate environment created with pyenv or conda, to avoid dependencies issues with other preinstalled packages in the base environment. The following dependencies will be installed along with SCLUDAM:numpy>=1.21.6matplotlib>=3.4.1scipy>=1.7.3astropy>=4.3.1astroquery>=0.4.6pandas>=1.3.5hdbscan==0.8.27scikit-learn>=1.0.2scikit-image>=0.18.1rpy2>=3.5.2seaborn>=0.11.0attrs>=21.4.0beartype>=0.10.0ordered_set>=4.0.2statsmodels>=0.12.2diptest>=0.4.2typing_extensions>=4.2.0User install in a Conda environment (recommended)Create a conda environment namedmyscludamenvwith python3.8 andscludaminstalledconda create --name myscludamenv python=3.8 pip --yes
conda activate myscludamenv
python -m pip install scludamUpdate scludam in a Conda environmentconda activate myscludamenv
python -m pip install -U scludam
python -m pip show scludamSimple user installInstall from PyPi:python -m pip install scludamSimple user updateUpdate from PyPi:python -m pip install -U scludamDev installClone the repo and run the following command in the cloned directory (with your environment activated):python -m pip install -e .[dev]
Package: scluster
Homepage:http://github.com/whym/sclusterContact:http://whym.orgOverviewSpectral clustering a modern clustering technique considered to be effective for image clustering among others.[1][2]This software find clusters among documents based on the bag-of-words representation[3]and TF-IDF weighting[4].[1]Ulrike von Luxburg, A Tutorial on Spectral Clustering, 2006.http://arxiv.org/abs/0711.0189[2]Chris H. Q. Ding, Spectral Clustering, 2004.http://ranger.uta.edu/~chqding/Spectral/[3]http://en.wikipedia.org/wiki/Bag_of_words_model[4]http://en.wikipedia.org/wiki/Tf%E2%80%93idfRequirementsFollowing softwares are required.Python 2 or 3NumpyScipyHow to usePrepare documents as raw-text files, and put them in a directory, for example, ‘reuters’.Prepare a category file. For example, ‘cats.txt’ may contain:14833 palm-oil veg-oil
14839 shipThis means that the file ‘14833’ has ‘palm-oil’ and ‘veg-oil’ as
its categories, and ‘14839’ has ‘ship’ as its category.Run:python scluster/clusterer.py cats.txt reusters/-mkmeans,NotesWhen you use the Reuters set, notice No 17980 might contain
non-Unicode character at Line 10. It should probably read: “world
economic growth-side measures …”[5]http://www.daviddlewis.com/resources/testcollections/reuters21578/
Package: scmagneto
MAGNETO: Marker pAnels GeNEraTor with multi-Objective optimizationMAGNETO is a user-friendly and fully-automatic framework that exploits Multi-objective Evolutionary Algorithms (MOAEs) to solve a tailored bi-objective optimization problem, specifically designed to build effective marker panels.
MAGNETO can thus help researchers to identify the most promising marker panels, starting from a gene expression matrix with single-cell resolution data and a cell type identity for each cell.For further information please visit:https://gitlab.com/andrea-tango/magnetoWe’re always happy to hear of any suggestions, issues, bug reports, and possible ideas for collaboration.Andrea Tangherloni <andrea.tangherloni@unibocconi.it> (Bocconi University, Italy)Simone Riva <simone.riva@imm.ox.ac.uk> <simo.riva15@gmail.com> (University of Oxford, UK)
Package: scmags
scMAGS: Marker Gene Selection From scRNA-seq Data for Spatial Transcriptomics Studies-> scmags selects marker genes from scRNA-seq data that are exclusive to each cell type such that, selected marker genes are highly expressed in a specific cell type while lowly expressed in other cell types.Installation-> scmags can be installed as follows:$ pip install scmags-> You can also install the development version of scmags from master branch of Git repository:$ pip install git+https://github.com/doganlab/scmags-> Seetutorialfor more detailed information.
Package: sc-mainwindow
sc_mainwindow is a pyqt5 custom widget. This widget provides a custom frame. You can move the window using the title bar and can resize the window by using the frame. It does not depend upon os. Also, you can customize anything.AuthorSihinaCode Youtube channel.click here to visitInstallationUse the package managerpipto install sc_mainwindow.pipinstallsc-mainwindowUsagemain windowfromPyQt5importQtWidgetsfromsc_mainwindowimportMainWindowimportsysclassMain(MainWindow):def__init__(self):super(Main,self).__init__()if__name__=="__main__":app=QtWidgets.QApplication(sys.argv)Form=Main()Form.show()sys.exit(app.exec_())fromPyQt5importQtWidgetsfromsc_mainwindowimportMainWindow#from body import Body               #import your pyqt5 Body class hereimportsysclassMain(MainWindow):def__init__(self):super(Main,self).__init__()#window size#self.resize(800, 600)#enable/disable the ability to resize the window - default: 1#self.resizable = 0#title text - default:untitled#self.setTitleText("title text")#title bar icon#self.setIcon("path of image")#transparency of window (0 - 1) - default: 1#self.setTransparent(0.9)#enable/disable frame shadow - default: 1#self.setFrameShadow(0)#body = Body()#self.insertBody(body)#self.setTitleBarColor(0, 0, 0)#self.setShadowColor(0, 0, 0)#self.setBorderColor(0, 0, 0)#self.titleBar.hide()#self.minimizeButton.hide()#self.maximizeButton.hide()#self.closeButton.hide()if__name__=="__main__":app=QtWidgets.QApplication(sys.argv)Form=Main()Form.show()sys.exit(app.exec_())bodyfromPyQt5importQtWidgets,QtCore,QtGuifrombodyUiimportUi_Form#your UI classclassBody(QtWidgets.QWidget,Ui_Form):def__init__(self):super(Body,self).__init__()self.setupUi(self)SupportVisit the SihinaCode YouTube channel for support.click hereLicenseMIT
Package: scmap
scmapAssigns rgb colors to points on sphere (orientations in 3D).InstallationInstall the module usingpip install scmapor clone the repository.UseThe simplest example involves coloring random 3D vectors.importscmapimportnumpyasnpvectors=np.random.standard_normal(size=(1000,3))coloring=scmap.Ico()colors=coloring(vectors)Sphere colormap (scmap) can be oriented by either perumuting vector coordinates, rotating vectors, or defining a z-direction. Check the examples to see how this is accomplished.Different colorspheresScmap module includes 4 special spere colormaps.Unois suitable when orientations are predominantly uindirectional,Duois suitable when orientations are predominantly in a plane,Treis suitable when orentations are to be interpeted as being predominantly in x, y or z direction,Icois suitable when there is no predominant orientation. We also include 2 simpler colormaps:Incwhich assigns colors based on inclination, andAzywhich colors azymuth.
Package: scmappy
SCMAPpyPython version of scmap as described from the original paper ofKilesev et al. (2017)It integrates with scanpy objects.On top of the original algorithm, we implement a few additional functions.UsageThe purpose of this package is to map the annotations of a reference single-cell dataset (reference) into a target dataset (target). The package is implemented to be used withAnnData objectsandScanpy environment.We implement three functions to do this pipeline of annotation.common_genes: Function to find the common genes between both datasets.scmap_annotate: Function to anotate the target dataset that implements the original scmap function.scmap_projection: Function to project the target dataset into a representation of the reference dataset.ExampleConsider areferenceand atargetdatasets. The genes are annotated in.var["Gene_names"]. The annotations are inreference.obs["Annotation"]The first step for the annotation is to find the common genes between both datasets.reference,target = common_genes(reference,target,"Gene_names",remove_unmached=True)Before proceeding to the mapping, we need to select that are going to be used for the mapping, as using the hole genome will have the curse of dimensionality. There are different flavors for selecting the genes that do not require this step, but the most typical is to use the highly varying genes. For that you have to first run thescanpy.pp.highly_varying_genesalgorithm in the reference dataset.scanpy.pp.highly_varying_genes(reference)With the common genes detected and the genes on interest selected, we can proceed to map the data.scmap_annotate(reference,target,"Gene_names","Annotation",algorithm_flavor="centroid",gene_selection_flavor="HVGs",similarity_threshold=.7, key_added="scmap_annotation")That is it. By default there will be a new column added intarget.obswith the annotations.In the case that we would also to visualize where the annotated cells where projected in a representation of the data, we can use the projection function. Consider that we have a UMAP representation inreference.obsm["X_umap"]. We would do,scmap_projection(reference,target,"Gene_names","X_umap",algorithm_flavor="centroid",gene_selection_flavor="HVGs",key_added="scmap_annotation")and this will add atarget.obsm["scmap_annotation"]with the projected cells.
Package: scmaui
scMaui is python package that implements a
variational auto-encoder for multi-omics data integration.
The model is capable of handling variable numbers input and output modalities
as well as missing modalities.
The model also features a range of log-likelihood implementations for determining the reconstruction
loss, including the negative binomial or the negative multinomial model.The package is freely available under a GNU Lesser General Public License v3 or later (LGPLv3+)Installationpip scmauiUsageimportpkg_resourcesfromscmaui.dataimportload_data,SCDatasetfromscmaui.utilsimportget_model_paramsfromscmaui.ensemblesimportEnsembleVAE# get some toy datatoy_data_path=pkg_resources.resource_filename('scmaui','resources/gtx.h5ad')adatas=load_data([toy_data_path],names=['gtx'])dataset=SCDataset(adatas,losses=['negbinom'])# create an scMaui modelparams=get_model_params(dataset)ensemble=EnsembleVAE(params=params)# fit the modelensemble.fit(dataset,epochs=10)ensemble.summary()# obtain latent featureslatents,_=ensemble.encode(dataset)# obtain an imputationimputed=ensemble.impute(dataset)# obtain input feature attributionsselected_cells=latents.index.tolist()[:5]# select first 5 cellsexplanation=ensemble.explain(dataset,cellids=selected_cells)Command-line usagescMaui offers a command line interface for model fitting.
The results are stored in an output directory (-output).scmaui -data adata.h5ad \
      -datanames gtx \
      -output <outputdir> \
      -epochs 200 \
      -ensemble_size 10 \
      -nlatent 15 \
      -adversarial label1 label2 \
      -conditional covariate1 covariate2 \
      -losses negmul negbinomAdditional information on available hyper-parameters are available throughscmaui -h