Saravanan666/pypi-org huggingface dataset:
Package: scENVI
ENVI - Integrating scRNA-seq and spatial data to impute missing genes and reconstruct spatial contextInstallationInstall ENVI (and COVET) through pypi:pip install scENVITutorialFor a tutorial on how to run ENVI and analyze the results, go to example notebook at:https://github.com/dpeerlab/ENVI/blob/main/MOp_MERFISH_tutorial.ipynb.UsageTo run ENVI:from scENVI import ENVI

ENVI_Model = ENVI.ENVI(spatial_data = st_data, sc_data = sc_data)
ENVI_Model.Train()
ENVI_Model.impute()
ENVI_Model.infer_cov()and to get the model's outputs:st_data.obsm['envi_latent'] = ENVI_Model.spatial_data.obsm['envi_latent']
st_data.obsm['COVET'] = ENVI_Model.spatial_data.obsm['COVET']
st_data.obsm['COVET_SQRT'] = ENVI_Model.spatial_data.obsm['COVET_SQRT']
st_data.uns['COVET_genes'] =  ENVI_Model.CovGenes

st_data.obsm['imputation'] = ENVI_Model.spatial_data.obsm['imputation']


sc_data.obsm['envi_latent'] = ENVI_Model.sc_data.obsm['envi_latent']
sc_data.obsm['COVET'] = ENVI_Model.sc_data.obsm['COVET']
sc_data.obsm['COVET_SQRT'] = ENVI_Model.sc_data.obsm['COVET_SQRT']
sc_data.uns['COVET_genes'] =  ENVI_Model.CovGenesAnd To run COVET (just on spatial data):ENVI.COVET(st_data, k = 8, g = 64, spatial_key = 'spatial')COVET information will be in:st_data.obsm['COVET'] 
st_data.obsm['COVET_SQRT'] 
st_data.uns['COVET_Genes']
Package: sceodesic
SceodesicSceodesic is a Python package that implements the gene program discovery algorithm described by Sinan Ozbay, Aditya Parekh, and Rohit Singh in “Navigating the manifold of single-cell gene coexpression to discover interpretable gene programs.” Given a single-cell gene expression dataset, Seodesic allows the user to:Discover meaningful gene programs from any single-cell gene expression data.Re-interpet gene expression data as levels of expression of the aforementioned gene programs.This repository contains an implementation of the algorithm.  Some examples of use can be found below in "Example Usage".InstallationYou can install Sceodesic by running the following in your command line:git clone https://github.com/rohitsinghlab/sceodesic.git
cd ./sceodesic  # to directory containing pyproject.toml file 
pip install .API Example UsageBelow is example usage of sceodesic in Python. First, make sure your single-cell gene expression data is in an anndata object, as below.importanndataadata=[singlecellgeneexpressionanndataobject]Now, you are ready to discover some programs!fromsceodesicimportrun_sceorun_sceo(adata,num_hvg=300)embeddings=adata.obsm['sceo_embeddings']# programs (loadings) stored in .varm, as a numpy arrayprograms=adata.varm['sceo_programs']embeddingsis a 2D numpy array where rows represent cells and columsn represent levels of gene program expression.programsis a 2D numpy array where columns represent individual gene programs, with each entry of that column giving the weight of each individual gene\ in that program. After you have generated programs and the embeddings, it becomes possible to do a wide variety of downstream single cell analysis using these embeddings.  For example, if our data is labelled by cell type with anobscolumn called "cell_type" , we can compute differential gene program expression across cell types as follows:# Create new anndata object with embeddingsadata_sceo=anndata.AnnData(embeddings,obs=adata.obs)sc.get.rank_genes_groups_df(adata=adata_sceo,group=“cell_type”)
Package: sceptre-aws-asg-scaling-processes-hook
ASG Scaling ProcessesSuspends or resumes autoscaling scaling processes.Syntax:<hook_point>:-!asg_scaling_processes<suspend|resume>::<process-name>Example:before_update:-!asg_scaling_processessuspend::ScheduledActionsMore information on suspend and resume processes can be found in the AWSdocumentation.
Package: sceptre-aws-resolver
sceptre-aws-resolverSceptreresolver for any AWS API.
Get started by runningpip install sceptre-aws-resolverFormat:!aws client::operation::optional_parameters::optional_jmespath_filter.Examples:Return call to STSGetCallerIdentityin string format:!aws sts::get_caller_identityGet current UserId:!aws sts::get_caller_identity::::UserIdRead a systems manager parameter and return its value:!aws ssm::get_parameter::'Name':'your-param-name'::Parameter.ValueRead a systems manager parameter and return itsdecryptedvalue if necessary:!aws ssm::get_parameter::'Name':'your-secret-param','WithDecryption':True::Parameter.ValueSee the jmespath package for query examples:https://pypi.org/project/jmespath/Released under the simplified BSD licence. SeeLICENCE.txtfor details.Thanks to thehttps://github.com/zaro0508/sceptre-date-resolverproject for providing the boilerplate.
Package: sceptre-aws-stackoutput-external-resolver
Stack Output ExternalFetches the value of an output from a different Stack in the same account and
region. You can specify a optional AWS profile to connect to a different
account/region.If the Stack whose output is being fetched is in the same StackGroup, the
basename of that Stack can be used.Syntax:parameters/sceptre_user_data:<name>:!stack_output_external<full_stack_name>::<output_name><optional-aws-profile-name>Example:parameters:VpcIdParameter:!stack_output_externalprj-network-vpc::VpcIdOutput prod
Package: sceptre-aws-stackoutput-resolver
StackOutput ResolverFetches the value of an output from a different Stack controlled by Sceptre.Syntax:parameters | sceptre_user_data:<name>:!stack_output<stack_name>.yaml::<output_name>Example:parameters:VpcIdParameter:!stack_outputshared/vpc.yaml::VpcIdOutputSceptre infers that the Stack to fetch the output value from is a dependency,
and builds that Stack before the current one.This resolver will add a dependency for the Stack in which needs the output
from.
Package: sceptre-cmd-resolver
Sceptre shell command resolverThis resolver can be used to execute any shell command.Why?This resolver is handy, because it allows you to dynamically resolve parameters at runtime.
The beautiful thing about it is that it's infintely extensible! You can use it to connect
any command line tool to Sceptre.Use it in conjunction with the typical unix tools (cat, cut, grep etc...) or third party
ones (vault, op, etc...)Use the!rcmdtag to activate the resolver. You can also use pipe commands, and generic
bash (maybe powershell too but I haven't tried it).The yaml tag!cmdis already used by sceptre hooks, unfortunately it wasn't possible to use
the same YAML tag for this custom resolver, so the tag!rcmdwas used instead.Installation# To install directly from PyPI
pip install sceptre-cmd-resolver

# To install from this git repo
pip install git+https://github.com/Sceptre/sceptre-resolver-cmd.gitUsage / ExamplesUse the!rcmdtag to activate the resolver. You can also use pipe commands, and generic
bash (perhaps even powershell but I haven't tested it).# Resolve the contents of a file with catparameters:DatabasePassword:!rcmdcat .env/dev/password# Resolve data from a json file with cat + jqparameters:DatabasePassword:!rcmdcat .env/data | jq -r '.Passwords.dev'# Resolve a secret in vault using the vault CLI (you must be logged in!)parameters:DatabasePassword:!rcmdvault kv get -field=password myapp/database/devparameters:# Resolve the EC2 AMI Image ID to the latest official version of Ubuntu 20.04 at deploy timeEC2ImageIdUbuntu:!rcmd>-aws ssm get-parameters--region eu-west-2--names /aws/service/canonical/ubuntu/server/20.04/stable/current/amd64/hvm/ebs-gp2/ami-id--query 'Parameters[0].[Value]' --output text# Resolve the EC2 AMI Image ID to the latest official version Windows Server 2019 at deploy timeEC2ImageIdWindows:!rcmd>-aws ssm get-parameters--region eu-west-2--names /aws/service/ami-windows-latest/Windows_Server-2019-English-Full-Base| jq -r '.Parameters[0].Value' | jq -r '.image_id'# Add a human readable comment with the deployment dateparameters:DeployNote:!rcmdecho "Deployed by `whoami` on `date` :-)"# Execute the command with the same AWS profile provided to Sceptreparameters:CanonicalUserId:!rcmdcommand:"awss3apilist-buckets--queryOwner.ID--outputtext"# Override the command execution with a specific AWS profile, region, and/or sceptre_roleparameters:CanonicalUserId:!rcmdcommand:"awss3apilist-buckets--queryOwner.ID--outputtext"profile:"my-profile"region:"us-west-2"sceptre_role:"arn:aws:iam::123456:role/my-role-to-override-the-stack-role"
Package: sceptre-core
SceptreAboutSceptre is a tool to driveAWS CloudFormation. It automates the
mundane, repetitive and error-prone tasks, enabling you to concentrate on
building better infrastructure.Install$ pip install sceptre-coreMore information on installing sceptre can be found in ourInstallation GuideExampleSceptre organises Stacks into "Stack Groups". Each Stack is represented by a
YAML configuration file stored in a directory which represents the Stack Group.
Here, we have two Stacks,vpcandsubnets, in a Stack Group nameddev:$ tree
.
├── config
│   └── dev
│        ├── config.yaml
│        ├── subnets.yaml
│        └── vpc.yaml
└── templates
    ├── subnets.py
    └── vpc.pyUsageSceptre can be used from the CLI (seesceptre-cli), or imported as a Python
package.Python APIUsing Sceptre as a Python module is very straightforward. You need to create a
SceptreContext, which tells Sceptre where your project path is and which path
you want to execute on, we call this the "command path".After you have created a SceptreContext you need to pass this into a
SceptrePlan. On instantiation the SceptrePlan will handle all the required steps
to make sure the action you wish to take on the command path are resolved.After you have instantiated a SceptrePlan you can access all the actions you can
take on a Stack, such asvalidate(),launch(),list()anddelete().fromsceptre.contextimportSceptreContextfromsceptre.plan.planimportSceptrePlancontext=SceptreContext("/path/to/project","command_path")plan=SceptrePlan(context)plan.launch()Full API reference documentation can be found in theDocumentationUse Docker ImageView ourDocker repository.To use our Docker image follow these instructions:Pull the imagedocker pull cloudreach/sceptre-core:[SCEPTRE_VERSION_NUMBER]e.g.docker pull cloudreach/sceptre-core:x.x.x. Leave out the version
number if you wish to runlatestor rundocker pull cloudreach/sceptre-core:latest.Run the image. You will need to mount the working directory where your
project resides to a directory calledproject. You will also need to mount
a volume with your AWS config to your docker container. E.g.If you want to use a custom ENTRYPOINT simply amend the Docker command:docker run -ti --entrypoint='' cloudreach/sceptre-core:latest shThe above command will enter you into the shell of the Docker container where
you can execute sceptre commands - useful for development.If you have any other environment variables in your non-docker shell you will
need to pass these in on the Docker CLI using the-eflag. See Docker
documentation on how to achieve this.Tutorial and DocumentationGet StartedDocumentationContributingSee ourContributing Guide
Package: sceptre-date-resolver
OverviewThe purpose of this resolver is to retrieve the current datetimeInstallpipinstallsceptre-date-resolverAvailable ResolversdateFetches the current datetime in anISO 8601 format.
The default format is "%Y-%m-%d %H:%M:%S".Syntax:parameter|sceptre_user_data:<name>:!dateExamples:Retrieve date (using default format) and pass it to a
cloudformation parameter:parameters:now:!dateRetrieve the date (in MM/DD/YYYY format) and pass it to a
cloudformation parameter:parameters:now:!date"%m/%d/%Y"Retrieve the time (in H:M:S format) and pass it to a
cloudformation parameter:parameters:now:!date"%H:%M:%S"
Package: sceptre-dot
Helps you visualise your Sceptre projects with Graphviz (DOT).BenefitsVisualisation can be added as a documentation artefact to your projectHaving many explicit/implicit dependencies can slow down deployments. Use the generated dependency graph to quickly spot bottlenecks due to these dependencies.InstallationInstall graphviz for your operating system as perofficial instuctions.Install this package in the same python interpreter (virtualenv) that Sceptre is installed so that its python library is already available:pip install sceptre-dotUsageIn the same directory where you would normally invokesceptre launch -y $YOUR_PATH, run:sceptre-dot$YOUR_PATH>output.dot
fdp-Tpngoutput.dot-ooutput.png# use fdp engine for best resultsReleased under the Simplified BSD Licence.
Package: sceptre-eks-lb-resolver
sceptre-eks-lb-resolverSceptrecustomresolveryou can
use to dynamically readAWS EKSLoad Balancer URI into your Sceptreconfig.It readsservicesinside your Kubernetes cluster with typeLoadBalancerand returns its External DNS/URI.Installation$>pipinstallsceptre-eks-lb-resolverUsageSimply call the resolver inside your Sceptre configuration files:template_path:mystack.yamlparameters:ProjectName:"Myk8sAPI"LoadBalancerURI:!eks_lb_uri-n backend -s data_apiWill resolve to something like:LoadBalancerURI:"XXXXXXXXXXX.us-east-1.elb.amazonaws.com"You can use your Sceptrevariablesas arguments for the resolver:...LoadBalancerURI:!eks_lb_uri-n {{ var.namespace }} -s {{ var.service }}So with that in place, when you runsceptre launch --yes dev/us-east-1, it
will call the resolver and assign the k8s load balancer URI to the Sceptre
variableLoadBalancerURIat runtime.Make sure to guarantee that you are properly authenticated within AWSSyntaxResolver expects two arguments:-n | --namespaceand-s | --service-name.
The--namespaceargument is optional. It assumes kubeernetesdefaultnamespace
as its default value.All available ways of using this resolver are as follows:LBArn:!eks_lb_uri--namespace {{ var.namespace }} --service-name {{ var.service }}LBArn:!eks_lb_uri-n {{ var.namespace }} -s {{ var.service }}LBArn:!eks_lb_uri-s {{ var.service }}# Assumes default namespaceLBArn:!eks_lb_uri-s "my_api_service_name"LBArn:!eks_lb_uri-n backend -s data_apiHow does it works?The resolver is called by Sceptre in order to retrieve remote k8s cluster services.
The EKS Load Balancer Resolver uses kubernetes python client to connect on the remote
cluster and retrieve data of the given service name from a given namespace.The K8s Load Balancer URI resolver simply tries to get the Load Balancer DNS as if you run:$>kubectl--namespacebackendgetserviceapi-service
NAMETYPECLUSTER-IPEXTERNAL-IPPORT(S)AGE
api-serviceLoadBalancer10.0.42.123XXXXXXXXXXX.us-east-1.elb.amazonaws.com443:32214/TCP12h40mThe resolver goes after theXXXXXXXXXXX.us-east-1.elb.amazonaws.comvalue. When succeeds, it loads in place this
value in your Sceptre template.NotesBe aware that the shell which sceptre will be called MUST be authenticated on AWS and
your kubeconfig properly updated to point to your AWS EKS remote cluster.You can refer to the following links for either AWS and Kubernetes authentication:AWS CLI ConfigurationAWS EKS Kubeconfig setupContributingFork, change, make test, make check, Pull Request.
I will review the code and if Github Actions pipeline succeeds: congratulations! We are going to merge ;)
Package: sceptre-file-resolver
File ResolverA Sceptre resolver to get file contents.  The returned value can be
passed into a parameter as a string, json, or yaml object.  The
file extension determines the return type.  By default, contents from
any files that do not end in.jsonor.yamlwill be passed in as
a string.MotivationUnlike thefile_contents resolverwhich can only pass strings to parameters this resolver can also pass file
content in as json and yaml object.  This resolver can also resolve remote file
contents from the web.Syntaxparameters|sceptre_user_data:<name>:!file/path/to/local/fileparameters|sceptre_user_data:<name>:!fileURL/To/FileExamplesLocal filetextGet file content and pass it to the parameter as a text string:tags/departments.txt"HR, Governance, Engineering, Marketing"parameters:departments:!filetags/departments.txtjsonGet file contents and pass it to the parameter as a json object:tags/departments.json["HR","Governance","Engineering","Marketing"]parameters:departments:!filetags/departments.jsonyamlGet file contents and pass it to the sceptre_user_data as a yaml object:tags/departments.yaml-"HR"-"Governance"-"Engineering"-"Marketing"sceptre_user_data:departments:!filetags/departments.yamlNote: will do the same for files with.ymlextension.Remote fileWorks similarly to local file except this will get file contents from the web.URLGet file contents from a URL reference:sceptre_user_data:departments:!filehttps://my-bucket.s3.us-east-1.amazonaws.com/tags/departments.json
Package: sceptre-formatted-yaml-handler
READMEOverviewTheformatted_yamltemplate handler enhances Sceptre's built-inFilehandler by delivering YAML output that is not only rendered but also reformatted according to an opinionated style aimed at improving readability. This feature is particularly useful for templates that utilize Jinja interpolation, which often introduces unwanted whitespace into the rendered output. By employing theformatted_yamlhandler, Sceptre users can ensure that their YAML configurations are visually appealing both in the Jinja source code and in the generated output and without spending time navigating Jinja's whitespace management features.InstallationInstallation instructionsTo install directly from PyPIpipinstallsceptre-formatted-yaml-handlerTo install from the git repopipinstallgit+https://github.com/Sceptre/sceptre-formatted-yaml-handler.gitUsage/ExamplesRefer to theSceptre template handler docsfor more information.template:type:formatted_yaml
Package: sceptre-git-clone-hook
Git CloneThis package is a Sceptre Hook to clone a git repository. It executes two actions:removes, if exists, the current folder that you have passedclones the git repository that you have passed, in that folderInstallationgitclonehttps://github.com/bilardi/sceptre-git-clone-hookcdsceptre-git-clone-hook
makepluginTARGET=<relative_path_of_existing_sceptre_project_root>SyntaxYou have to pass two parameters:thegit repository urlcan have the follow protocols: http, https or gitthe localrepository folderis a relative path from your Sceptre project root where you want to clone the repositoryYou can clone more git repositories using the syntax below for each git repository you need<hook_point>:-!git_clone<git repository url> <repository folder>or you can clone one git repository and save the details in the property namedsceptre_user_data, for using them in other steps<hook_point>:-!git_clonesceptre_user_data:GitRepository:<git repository url>RepositoryFolder:<repository folder>ExampleFor cloning one repository before create the stackbefore_create:-!git_clonehttps://github.com/bilardi/sceptre-git-clone-hook my-folderfor cloning two different repositories before create the stackbefore_create:-!git_clonehttps://github.com/bilardi/sceptre-git-clone-hook my-folder-one-!git_clonehttps://github.com/bilardi/sceptre-zip-code-s3 my-folder-twoor for cloning one repository before create the stack and sharing the details with other stepsbefore_create:-!git_clonesceptre_user_data:GitRepository:https://github.com/bilardi/sceptre-git-clone-hookRepositoryFolder:my-folderDevelopment# after your changepython3-mpytesttests/test_git_clone.py
gitadd.
gitcommit
bumpversion--dry-run--verbosepatch|minor|major
bumpversionpatch|minor|major
gitpushoriginmaster
gitpushoriginvX.Y.Z
Package: sceptre-hook-template
READMEAdd your hook readme here. Remember to include the following:Tell people how to install it (e.g. pip install ...).Be clear about the purpose of the hook, its capabilities and limitations.Tell people how to use it.Give examples of the hook in use.Read our wiki to learn how to use this repo:https://github.com/Sceptre/sceptre-hook-template/wikiIf you have any questions or encounter an issueplease open an issue
Package: sceptre-json-resolver
sceptre-json-resolverA Sceptre resolver to serialize and deserialize json.MotivationThere are use cases where you may want to pass in either a string
or a json object to a cloudformation or sceptre_user_data parameter.
This simple resolver can take some json and serialize it or deserialize
it before passing it into a cloudformation parameter or a
scepter_user_data parameter.InstallationTo install directly from PyPIpipinstallsceptre-json-resolverTo install from this git repopipinstallgit+https://github.com/Sceptre/sceptre-json-resolver.gitUsage/Examplesparameters|sceptre_user_data:<name>:!from_json[<string>]parameters|sceptre_user_data:<name>:!to_json[<json object>]NOTE: This resolver expects a single-item list argument.Basic ExamplesTake some json object serialize it to a string then pass it to a parameter:parameters:myparam:!to_json[{"key":"value"}]Note: The string'{"key": "value"}'is passed to myparamTake a string deserialize it to a json object then pass it to a parameter:sceptre_user_data:myparam:!from_json['{"key":"value"}']Note: The object{"key": "value"}is passed to myparamNested resolver examplesThese use case requires the nested resolver feature in
Sceptre version 4.1 and greater.Load a json object from a file using thesceptre file resolver,
serialize the object to a string then pass it to a parameter:parameters:hounds:!to_json[!file'hounds.json']Make a request to a REST API using thesceptre-request-resolver,
deserialize the response to a json object then pass it to a parameter:sceptre_user_data:hounds:!from_json-!request'https://dog.ceo/api/breed/hound/list'
Package: sceptre-kms-resolver
OverviewThe purpose of this resolver is to retrieve values from the AWS KMS.Installpipinstallsceptre-kms-resolverAvailable ResolverskmsFetches the value stored in AWS KMS.Syntax:parameter|sceptre_user_data:<name>:!kmsCIPHERTEXTExample:Encrypt data with KMS to get a Ciphertext:aws kms --key-id <KMS Key Id> --plaintext <data> --output text --query CiphertextBlob

AQICAHhZyEsV0yflwE0mpKvPz7/O/zc1epgIurV43wXF/qF6MwFQYwZq7TrvtQ2....Use sceptre to retrieve and decrypt the value from KMS:parameters:
    database_password: !kms AQICAHhZyEsV0yflwE0mpKvPz7/O/zc1epgIurV43wXF/qF6MwFQYwZq7TrvtQ2...
Package: sceptre-minify-file-contents-resolver
Minify File Contents ResolverReads in the contents of a file and minifies them if applicable.Syntax:parameters|sceptre_user_data:<name>:!minify_file_contents/path/to/file.txtExample:sceptre_user_data:inline_lambda_code:!minify_file_contents/path/to/policy.jsTestingmake testReleasingUpdate the CHANGELOG.md with what has changed (see the example in the CHANGELOG comments).In your virtualenv runbumpversion --dry-run --verbose patch|minor|major. You will see that the version number will be updated, a commit is made for the version update and a new git tag will be created.If you are happy with the dry run then executebumpversion patch|minor|major.Push the commit withgit push.When the build for the above step is complete push the taggit push origin vX.Y.Zthis will trigger a release build which will deploy to PyPi.
Package: sceptre-openapi-substitution-hook
READMEOverviewPerforms simple string substitution in openapi specifications.Should be used until CloudFormationnatively supports this feature.InstallationInstallation instructionsTo install directly from PyPIpython3-mpipinstallsceptre-openapi-substitution-hookTo install from the git repopython3-mpipinstallgit+https://github.com/nicholasphair/sceptre-openapi-substitution-hookUsage/ExamplesUse the hook with ahook pointhooks:<hook_point>:-!openapi_substituteropenapi:input:<input_path>output:<output_path>substitutions:<key>:<val>The substituer will look for strings in the form of${<key>}and replace them
with<val>.Examplehooks:before_validate:-!openapi_substituteropenapi:input:../templates/openapi.yamloutput:../templates/openapi.yamlsubstitutions:foo:barbaz:qux