Saravanan666/pypi-org huggingface dataset:
Package: nebari-plugin-metrics-server
Nebari Plugin - Metrics ServerOverviewThis plugin integrates Metrics Server into the Nebari platform, allowing container resource metrics for Kubernetes built-in autoscaling pipelines within Nebari. Utilizing Python, Terraform, and Helm, the plugin provides a configurable deployment.Design and ArchitectureThe plugin follows a modular design, leveraging Terraform to define the deployment of Metrics Server within a Kubernetes cluster. Key component is:Terraform Configuration: Defines variables and Helm release for deployment.Installation Instructionspip install nebari-plugin-metrics-serverUsage InstructionsConfigurations: Various configurations are available, including name, namespace, and affinity settings.Configuration DetailsPublicConfiguration of the Metrics Server plugin is controlled through themetrics_serversection of thenebari-config.yamlfor the environment.metrics_server:# helm release name - default metrics-servername:metrics-server# target namespace - default kube-systemnamespace:kube-system# configure default affinity/selector for chart componentsaffinity:enabled:true# defaultselector:general# default# -- or --selector:default:generalworker:workerdb:generalauth:general# helm chart values overridesvalues:{}InternalThe following configuration values apply to the internally managed terraform module and are indirectly controlled through related values innebari-config.yaml.name: Chart name for Helm release.namespace: Kubernetes namespace configuration.affinity: Affinity configuration for Helm release.overrides: Map for overriding default configurations.Licensenebari-plugin-metrics-serveris distributed under the terms of theApachelicense.
Package: nebari-plugin-mlflow-aws
Nebari Plugin MLflow AWSTable of ContentsFeaturesInstallationUsageLicenseIntroductionThis MLflow extension is designed to integrate into Nebari deployments utilizing the AWS provider. It provides a robust, collaborative environment for AI/ML professionals to manage experiments, track metrics, and deploy models.FeaturesCentralized Artifact Repository: Store and manage all your metrics, parameters, and artifacts in a single location, accessible across the multi-tenant platform.Experiment Tracking: Log, query, and visualize metrics to understand and compare different runs and models.Automated Configuration: Simply type import mlflow in your Python script, and you're already configured to communicate with the remote multi-tenant MLflow server—no additional setup required.InstallationPrerequisites:Nebari must be deployed using the provider AWSNebari version 2023.10.1 or laterInstalling the MLflow extension is as straightforward as installing a Python package. Run the following commands:gitclonenebari-plugin-mlflow-awscdnebari-plugin-mlflow-aws/
pipinstallnebari-plugin-mlflow-awsThis command installs the Python package and also creates the necessary infrastructure to run MLflow on the AI Platform.ConfigurationAfter installation, the MLflow extension is automatically configured to work with the AI Platform. To access the MLflow interface, navigate tohttps://[your-nebari-domain]/mlflow.Configuring MLFlow Kubernetes NamespaceIn order for MLflow to deploy into a non-default Kubernetes namespace, you may add an mlflow block to your Nebari configuration file such as the example below. Although MLflow resources should all be prefixed to avoid collisions, we still recommend this as a best practice.mlflow:namespace:mlflowExposing MLflow workload via IngressIn order for the traefik ingress to route users' web requests to the MLflow workload, add or update the block in your Nebari configuration file. Be sure to update this block if you've configured a namespace other thanmlflow.ingress:terraform_overrides:additional-arguments:-"--providers.kubernetescrd.namespaces=mlflow"Configuring MLflow Tracking URLYou may set theMLFLOW_TRACKING_URLto configure mlflow in individual users' Nebari instances by adding or updating an additional block in your Nebari configuration file. Note that the first 'mlflow' in the URL below corresponds to the Kubernetes namespace where mlflow is deployed, so if you have assigned a custom namespace, that URL will need updating.jupyterhub:overrides:singleuser:extraEnv:MLFLOW_TRACKING_URI:"http://mlflow.mlflow:5000"UsageGetting started with the MLflow extension is incredibly simple. To track an experiment:Navigate to the MLFLow extension URL and create a new experiment.
In your Python script, import MLflow and start logging metrics.importmlflow# Start an experimentwithmlflow.start_run()asrun:mlflow.log_metric("accuracy",0.9)mlflow.log_artifact("path/to/your/artifact")With the above code, your metrics and artifacts are automatically stored and accessible via the MLFlow extension URL.Licensenebari-plugin-mlflow-awsis distributed under the terms of theApachelicense.
Package: nebari-workflow-controller
Nebari Workflow ControllerAkubernetes admission controllerto enable volumeMount permissions on Argo Workflows on Nebari and provide a convenience method for deploying jupyterlab-like workflows for users.Run projectpip install nebari-workflow-controllerpython -m nebari_workflow_controllerKnown LimitationsResubmitting workflows is not supported by Nebari Workflow Controller.Developing on this projectRunpip install -e .[dev]
Package: nebfa
Usage:>>> import nebfa
>>> rec = nebfa.parse(open("./test/data/basic.fa")).next()
>>> rec.id
('gi', '0120123123')
>>> rec.desc
'Some stuff'
>>> rec.sequence
'ACGT'
>>> rec.hash
'2108994E17F6CCA9FF2352ADA92B6511DB076034'# Alternatively, parse_file avoids the need for a call to open.
>>> for rec in nebfa.parse_file(“./test/data/multi.fa”):
…     print rec.id
(‘gi’, ‘0120123123’)
(‘ref’, ‘YP_234234.2’)Records also have a meta attribute that has two keys for identifiers and
descriptions. You will need to consult that member when you have Ctl-A separated
deflines. If you have a better syntax suggestion please send a note along.
Package: nebgb
Usage:>>> import nebgb
>>> rec = nebgb.parse_file("./test/data/simple-1.gb").next()
>>> rec.locus["name"]
'NP_034640'
>>> rec.locus["length"]
182
>>> rec.keywords["source"]["name"]
'house mouse'
>>> rec.features[1]["properties"]["product"]
'interferon beta, fibroblast'
>>> for seq in rec.seqiter:
...    print seq
mnnrwilhaafllcfsttalsinykqlqlqertnirkcqelleqlngkinltyradfkip
memtekmqksytafaiqemlqnvflvfrnnfsstgwnetivvrlldelhqqtvflktvle
ekqeerltwemsstalhlksyywrvqrylklmkynsyawmvvraeifrnfliirrltrnf
qnAlternatively you can usenebgb.parse()to parse a string or iterator that yields lines of a Genbank file.
Package: nebgbhist
nebgbhistTools for building annotation histories from multiple Genbank files.Example$ mkdir gbhist
$ neb-rev-fetch -d gbhist NC_008512
$ neb-gbhist -d gbhist | neb-diff-apply NC_008512.git
$ git --git-dir=NC_008512.git gc --aggressive
$ neb-validate-history -p NC_008512.git -g gbhist/2009-04-29-04-04.gbkPlaying with filesIf you clone the pack repository after building you can poke around at the
contents on the file system. For larger genomes with lots of edits this may run
afoul of directory entry limits until I rewrite the object storage. For the
Carsonella (NC_008512) example I use there isn’t an issue.$ git clone NC_008512.git
$ cd NC_008512
$ ls -1
accession  dblink     keywords   objects/   seq/       version
comment    definition locus      ref/       sourceFiles in the root directory represent keywords defined in the Genbank file. The
ref and seq subdirectories contain information about references and the sequence
hashes. The objects directory lists the features in the history. The files
objects/known and objects/alive are dictionaries of hashes that point toward
the current version of a feature at a given location. Active features are
anything that is not deleted or replaced with a new version.I recommend that you work with nebpack.Pack objects if you want to actually do
anything with the objects.
Package: nebpyclient
Python API for NebulonThis is an API client for Nebulon ON for Python 3 and allows working with
Nebulon nPods just like with the Nebulon ON web user interface but in a
scriptable form.InstallationThe Nebulon Python SDK client is available through the Python Package Index
with the name nebpyclient, but can also be installed from source.IMPORTANT: Please review the changelog to transition from version 1.x of the
nebpyclient to version 2.x.Python Package IndexpipinstallnebpyclientOrpython3-mpipinstallnebpyclientInstallation from Source Codemkdirnebuloncdnebulon
gitclonehttps://github.com/nebulon/nebpyclient.gitcdnebpyclient
python3setup.pyinstallTo build the HTML documentation from source:cddocs/
makehtmlUsing the APITo use this API, instantiate aNebPyClientobject with username and password.
You can then use its methods to query state, and if a nPod is reachable from
where the script is being run modify the system. A simple script to display
the names of all of the pods in your organization along with a count of
the volumes in them would be:fromnebpyclientimportNebPyClientclient=NebPyClient("username","password")npod_list=client.get_npods()fornpodinnpod_list.items:print(f"nPod{npod.name}has{npod.volume_count}volumes")An example to create a 2 TiB volume calledvolume nameon an existing nPod
with the nameNPod Namewould be:fromnebpyclientimportNebPyClientfromnebpyclientimportNPodFilter,StringFilterclient=NebPyClient("username","password")# find the nPod by namenpod_list=client.get_npods(npod_filter=NPodFilter(name=StringFilter(equals="NPod Name")))ifnpod_list.filtered_count==0:# nPod with the name "NPod Name" not foundexit(-1)npod_uuid=npod_list.items[0].uuidvolume_name="volume name"volume_size_bytes=2*1024*1024*1024*1024# 2 TiB# create the volumeclient.create_volume(name=volume_name,size_bytes=volume_size_bytes,npod_uuid=npod_uuid)Full documentation on the API is available in thedocsdirectory.
Some functions have comments that describe functions and methods and are
visible in modern Python IDEs.Please review thecurrent version of the documentationfor more details.
Package: nebseq
Import as usual>>> import nebseqReverse complementsThe only note here is thatrevcompdoes not check the input
sequence to see if it looks like DNA or RNA.>>> nebseq.revcomp('ACGT')
'ACGT'
>>> nebseq.revcomp('TTACC')
'GGTAA'And if we give it garbage it just gives us garbage back.>>> nebseq.revcomp('ZQ')
'QZ'TranslationThe translation function should allow for full support of sequence
translation. This includes things like trimming the first couple
bases and using alternate translation tables. There is also
support for the more esoteric post translational modifications
that can be found in some Genbank files as well as translating
partial peptides (for things like fuzzy coordinates).Basic translation:>>> nebseq.translate('TTGGCCAAGGAACGA', table=11)
'MAKER'Showing the effects of a partial peptide translation. By default
the first codon should be a start codon according to the selected
translation table, if not then its converted to an ‘X’>>> nebseq.translate('GCCAAG')
'XK'
>>> nebseq.translate('GCCAAG', partial=True)
'AK'Or we can remove the first couple of bases for fuzzy coordinates.>>> nebseq.translate('TTGCCAAG', start=2, partial=True)
'AK'Modifications are specified as an (index, amino_acid) two-tuple. Notice
that modification indexes are specified as one-based indexes into the
amino acid sequence.>>> nebseq.translate('ATGAAGGAA', modifications=[(2, 'U')])
'MUE'ExtractionSequence extraction is for when you want to slice out part of a larger
sequence. This is useful if you use thenebgbmodule and its
definition of locations parsed from strings likejoin(1..5,9..100).>>> location = {'type': 'span', 'from': 4, 'to': 10}
>>> nebseq.extract('ACCGTACCATAGTT', location)
('GTACCAT', (False, False))
>>> location = {
...     "type": "complement",
...     "segment": {
...         "type": "join",
...         "segments": [
...             {"type": "span", "from": 3, "to": 8},
...             {"type": "span", "from": 10, "to": 14}
...         ]
...     }
... }
>>> nebseq.extract('ACCGTATTTCGGGGACAT', location)
('CCCCGAATACG', (False, False))
Package: nebula-cert-py
Nebula Cert PythonManager nebula certificates from PythonPrerequisiteThis library expects thenebula-certto be installed on host system.You can downloadlatest binaries from github:Windows (amd64)Linux (amd64)Linux (arm64)Linux (armv7)Quick startRunpython -m nebula.certorpyncto get started.If you want to generate a new configuration, runpync init --typ user --name <username>.Display files used bypyncpyncenvIssuing certificateCheck if a config already exist:pyncshow-configCreate a new signing request if no IP is shown:pyncedit-config--ip10.100.100.255/16--groups"users,quara"Sign a new certificatepyncsignCheck that files were created successfully:pyncenv
Package: nebula-chia
nebula-chiaHow To UseChaiBatchConvertorStep 0, Installationnebula-chiacould be installed either via pip or from this git repo itself.Install via pippython3-mpipinstallnebula-chiaInstall from the github repogitclonegit@github.com:wey-gu/nebula-chia.gitcdnebula-chia
python3setup.pyinstallNote:Nebula-chia depends onchia-blockchain, the easiest way is to call it from the venv inside the Chia Network repo.Install Chia Netowrk refers tohttps://github.com/Chia-Network/chia-blockchain/wiki/INSTALLActivate venv like:cdchia-blockchain
../activateStep 1, Convert Chia as CSV filesChiaBatchConvertoris used to convert Chia Block Chain data into CSV files, which could then be used for nebula-importer$python3-mpipinstallnebula-chia
$python# block_record_limit = 0 means unlimited# coin_record_limit = 0 means unlimitedfromnebulachia.convertorimportChiaBatchConvertorc=ChaiBatchConvertor(block_record_limit=0,coin_record_limit=0,write_batch_size=10000)c.convert_block_record()c.convert_coin_record()exit()$ls-lth

-rw-r--r--1weylstaff173MMay1913:01coin_record.csv
-rw-r--r--1weylstaff77MMay1912:59block_record.csv
...
Package: nebulacli
nebula-cliThis project is used with theNebula Serverto grant shell script and CLI access to theProvisioning API.On newly launched Nebula user instances this program can be in conjection with the system's provisioning system to-Notify Nebula when provisioning has completed,Change the Name of the instance without granting permission for the machine to edit other AWS Tags,Restrict access to the machine to a specific user.ConfigurationThe configuration file will be looked for in these places and in this order, using the first readable file that is found../.nebulacli (current working directory)~/.nebulacli/etc/nebulacliThe format of the file is simple-token_id = d9e5d9ba0735
token = 6566b5d5-90cb-4529-81c5-565a4b10a5cd
url = https://nebula.exampleInstallThis project can be installed using pip on a python3 system.For Ubuntu16 that means settings up python3 and pip, as the python2 variants will not work-apt-get install python3-pipNow you can run the install-pip3 install nebulacliNow the program should be available asnebulaclito the system.ExamplesTo tell the Nebula that provisioning is finished and the system is ready for use:nebulacli set_status LiveTo tell Nebula the prefered hostname for the system (allowing Nebula to set theNametag in AWS):nebulacli set_name $(cat /etc/hostname)HelpThis project is build using theclicklibrary, and if you run it with no options an up to date help menu will appear. From there you can get help on specific commands by using the--helpflag when calling any of them.
Package: nebulagraph-lite
NebulaGraph LiteTry NebulaGraph withpip install, on Linux/ WSL2 or evenGoogle ColaborModelScope Notebook, in container, rootless.How to useInstall NebulaGraph Litepip3installnebulagraph-liteStart NebulaGraph LiteFrom Jupyter Notebook:From CLI:fromnebulagraph_liteimportnebulagraph_letasng_letn=ng_let()n.start()nebulagraphstartVoilà! It'ts up and running already now!Free NebulaGraph Playground in 5 minutesThanks toGoogle ColabandModelScope Notebook, we could have a free NebulaGraph playground in 5 minutes.Go with 👉.In China?Go with 👉What's nextPlay withnebula3-pythonoripython-ngqland walk through theDocumentation!pip3installipython-ngql
%load_extngqlAnd we could access it like:%ngql--address127.0.0.1--port9669--userroot--passwordnebulaAnd query like:%ngqlSHOWHOSTS;Other non-lite or less-lite optionsIntrested in other play or production options?ProductionBinary Packages, if running on bare OS.K8s Operator, on K8s.NebulaGrpah Cloud, the managed NebulaGraph service.Play and DevDocker Compose, if you are comfortable to play with Docker on single server.nebula-up, one-liner test env installer on single server, support studio, dashboard, nebulagraph algorithm, exchange etc, all-in-one.Docker Extension, one-click on Docker Desktop(macOS, windows) on desktop machines, in GUI flavor.Nebula-Operator-KinD, Nebula K8s Operator with K8s-in-Docker, one-liner test env with docker+k8s+nebulagrpah-operator, try NebulaGraph on K8s with ease on your single server.Acknowledgementsudocker,https://github.com/indigo-dc/udocker, the foundation of this projectFakechroot,https://github.com/dex4er/fakechroot, the engine runs MetaD and StorageDPRoot,https://proot-me.github.io, the engine runs GraphD and Consoledocker-in-colab,https://github.com/drengskapur/docker-in-colab, inspired our Colab capablityNebulaGraph Docker,https://github.com/vesoft-inc/nebula-docker-compose, the container images we leveragedSupported PlatformsFAQClick to see FAQWhy not docker?With udocker, the opinionated subset docker running in user space, we could run docker images without root privilege, docker daemon.Thus we support running inside docker container, WSL2, Google Colab.Can NebulaGraph-Lite run inside a container?Yes! Say we are in a container that runs Ubuntu, we could run:dockerrun-it--rmubuntu:latestbash# inside the containeraptupdate&&aptinstallpython3-pipcurl-y
pip3installnebulagraph-lite
python3In python3:fromnebulagraph_liteimportnebulagraph_letasng_letn=ng_let(in_container=True)n.start()Or in shell:nebulagraph--containerstartDoes it support Windows?Yes, it supports Windows with WSL2 or other Linux VMs with a Hypervisor.How to clean up?Step 1, from nebulagraph-lite, remove the udocker container and clean up the base path.Python:n.stop()n.clean_up()Shell:nebulagraphstop
nebulagraphcleanupStep 2, pip uninstall nebulagraph-lite and dependencies.pip3uninstallnebulagraph-liteudockerStep 3, remove the udocker files.rm-rf~/.udocker
Package: nebulatest
# Example Package
This is a simple example package. You can use[contact author](https://www.bing.com/search?q=%E8%83%A1%E6%99%93%E6%AD%A6+%E5%BE%AE%E8%BD%AF&qs=n&form=QBRE&msbsrank=1_1__0&sp=-1&ghc=2&pq=%E8%83%A1%E6%99%93%E6%AD%A6+wei%27ruan&sc=1-12&sk=&cvid=26144FD435034889A901745088A95CC5)to write your content.
Package: nebulatest2
# Example Package
This is a simple example package. You can use[contact author](https://www.bing.com/search?q=%E8%83%A1%E6%99%93%E6%AD%A6+%E5%BE%AE%E8%BD%AF&qs=n&form=QBRE&msbsrank=1_1__0&sp=-1&ghc=2&pq=%E8%83%A1%E6%99%93%E6%AD%A6+wei%27ruan&sc=1-12&sk=&cvid=26144FD435034889A901745088A95CC5)to write your content.
Package: nebulizer
Command-line utilities to help with managing users, data libraries and
tools in aGalaxyinstance, using the
Galaxy API via theBioblendlibrary.Free software: Academic Free License version 3.0Documentation:https://nebulizer.readthedocs.ioCode:https://github.com/pjbriggs/nebulizerNoteNebulizer is still a work in progress.Please exercise caution when attempting irreversible operations,
especially against production Galaxy instances (for example when
creating users or data libraries).Quick StartThis quick start gives some examples of usingnebulizercommands
to perform remote administration tasks on a Galaxy instance from the
command line.Getting NebulizerIt is recommended to install Nebulizer viapipin a virtualenv,
for example:% virtualenv .venv
% source .venv/bin/activate
% pip install nebulizerThis will provide an executable callednebulizerwith a number
of subcommands for performing different tasks remotely on Galaxy
instances.Nebulizer BasicsGenerally Nebulizer commands take the form:nebulizer COMMAND GALAXY [OPTIONS]To interact remotely with a Galaxy instance using Nebulizer requires
at minimum the URL of the instance and then either an API key or a
user login name.For example to list the data libraries available on Galaxy Main:nebulizer -k 9b376af2250818d14949b3c list_libraries https://usegalaxy.orgornebulizer -u USER@DOMAIN list_libraries https://usegalaxy.orgIn this second case Nebulizer will prompt for the Galaxy
password to authenticate the user login, unless it’s supplied via
the-Poption.To store the Galaxy URL-API key pair against an aliasmain, to
avoid needing full authentication details each time:nebulizer add_key main https://usegalaxy.org 9b376af2250818d14949b3cor alternatively get Nebulizer to fetch the API key itself by
supplying the user login:nebulizer -u USER@DOMAIN add_key main https://usegalaxy.orgMore information on managing API keys in Nebulizer can foundhere.The stored alias is then used in subsequent commands, for example
to list the data libraries again it is now sufficient to do just:nebulizer list_libraries mainThe following sections contain examples of how Nebulizer might be
used to perform various administrive tasks.Nebulizer provides subcommands to perform various administrive tasks:Managing users:list_userscreate_usercreate_batch_userscreate_users_from_filedelete_userManaging data libraries:list_librariescreate_librarycreate_library_folderadd_library_datasetsManaging tools:list_toolslist_tool_panelinstall_toolupdate_tooluninstall_toolsearch_toolshedManaging quotas:quotasquota_addquota_modquota_delQuerying Galaxy instances:ping(check if a Galaxy instance is alive)config(fetch configuration for a Galaxy instance)See thetutorialfor a walkthrough some of these commands.ContributorsNebulizer has been developed by Peter Briggs @pjbriggs, with
contributions from:Hugo van Kemenade (@hugovk)Thanks to Peter van Heuseden (@pvanheus)
for porting Nebulizer into Bioconda.
Package: nebullvm
A framework for building optimization modules to boost the performances of your AI systemsDocumentation:docs.nebuly.com/Nebullvmis a framework for building the optimization modules needed to optimize the performances of your AI systems. The optimization modules are stack-agnostic and work with any library. They are designed to be easily integrated into your system, providing a quick and seamless boost to its performance. Simply plug and play to start realizing the benefits of optimized performance right away.If you like the idea, give us a star to show your support for the project ⭐What can this help with?There are multiple modules we actually provide built on top of the framework:✅Speedster: Automatically apply the best set of SOTA optimization techniques to achieve the maximum inference speed-up on your hardware.✅OpenAlphaTensor: Increase the computational performances of an AI model with custom-generated matrix multiplication algorithm fine-tuned for your specific hardware.✅Forward-Forward: The Forward Forward algorithm is a method for training deep neural networks that replaces the backpropagation forward and backward passes with two forward passes.Next modules and roadmapWe are actively working on incorporating the following modules, as requested by members of our community, in upcoming releases:CloudSurfer: Automatically discover the optimal cloud configuration and hardware on AWS, GCP and Azure to run your AI models.OptiMate: Interactive tool guiding savvy users in achieving the best inference performance out of a given model / hardware setup.ContributingAs an open source project in a rapidly evolving field, we welcome contributions of all kinds, including new features, improved infrastructure, and better documentation. If you're interested in contributing, please see thelinkedpage for more information on how to get involved.Join the community|Contribute to the library