Saravanan666/pypi-org huggingface dataset:
Package: cors-render-server-ext
Render Server ExtJupyter Server Extension serves files and provides a static build of Polus Render.RequirementsJupyter Server 2.7.0Adding a static build of Polus RenderRemove all existing files in~/render-server-ext/static/render-ui/.Runnpx nx build render-uiin the root of your Polus Render folderTransfer generated files from~/Polus Render/dist/apps/render-ui/into~/render-server-ext/static/render-ui/.API Endpoints/render/default/(.*): Help on usage of extension/static/render/render-ui/index.html: Serves static build of Polus Render./render/file/(.+): Serves files at a specfied path. Does not serve directories.ExamplesFor the following examples, JupyterLab is ran locally athttps://localhost:7832/labRender-UIURL:http://localhost:7832/static/render/render-ui/index.html?imageUrl=http://localhost:7832/render/file//home/jovyan/work/images/4by4large_intensity_image.ome.tifURL:http://localhost:7832/static/render/render-ui/index.html?imageUrl=http://localhost:7832/render/file//home/jovyan/work/images/x00_y01_p02_c1.ome.tif&overlayUrl=http://localhost:7832/render/file//home/jovyan/work/overlays/combined.jsonImageURL:http://localhost:7832/render/file/home/jovyan/work/samples/butterfly.jpegMarkdownURL:http://localhost:7832/render/file/home/jovyan/work/samples/README.md
Package: cortado
cortado: high performance 100% Python package for machine learningInstallationcortadocan be installed from pip:pip install cortadoMain features:native support for both numeric and categorical data (covariatesandfactors)innovative feature engineering: virtual data columns and easy conversions between numeric and categorical dataout of core data processing when dataframes are bigger than RAMimplementation of XGBoost logistic in 500 lines of Python code, 3x faster than original C++ implementation (using Numba jit under the hood)easy to extend, written in functional style for easy compositionworks well with pandas dataframesmore to come soon!Demo notebooks on Kaggle:Quick startCortado vs XGBoostFactors and covariatesOut of core processingHow to contributeAll contributions and bug reports are welcome.
Package: cortecs
cortecsA Python package for decreasing the memory footprint of opacity functions. The primary functionality is compressing opacity functions with varying flexibility. Current methods includepolynomial fittingPCA-based fittingneural network fittingAll fits are currently made in along the temperature and pressure axes.Additionally,cortecscan chunk up opacity functions. The radiative transfer problem can often be cast as embarassingly parallel, so each chunk can be sent to a different CPU.
Package: cortex4py
Cortex4pyCortex4py is a Python API client forCortex, a powerful observable analysis engine where observables such as IP and email addresses, URLs, domain names, files or hashes can be analyzed one by one using a Web interface.Cortex4py allows analysts to automate these operations and submit observables in bulk mode through the Cortex REST API from alternative SIRP platforms, custom scripts or MISP.FeaturesCortex4py 2 is compatible with Cortex 2 and does not work with Cortex 1. It can:Manage organizationsManage usersConfigure analyzers within an organizationList and launch analyzersFor more details, please refer to thefull documentation.Note: Cortex4py 2 requires Python 3. It does not support Python 2.Use ItOn macOS and Linux, type:sudo -H pip3 install cortex4pyor, if you already have it, update it:sudo -H pip3 install -U cortex4pyIf you are using Python on a Windows operating system, please forgo thesudocommand.LicenseCortex4py is an open source and free software released under theAGPL(Affero General Public License). We, TheHive Project, are committed to ensure that Cortex4py will remain a free and open source project on the long-run.UpdatesInformation, news and updates are regularly posted onTheHive Project Twitter accountand onthe blog.ContributingWe welcome your contributions. Please feel free to fork the code, play with it, make some patches and send us pull requests usingissues.We do have aCode of conduct. Make sure to check it out before contributing.SupportPleaseopen an issue on GitHubif you'd like to report a bug or request a feature. We are also available onDiscordto help you out.If you need to contact the project team, send an email tosupport@thehive-project.org.Community DiscussionsWe have set up a Google forum athttps://groups.google.com/a/thehive-project.org/d/forum/users. To request access, you need a Google account. You may create oneusing a Gmail addressorwithout one.Websitehttps://thehive-project.org/
Package: cortex-data-product-sdk
Cortex Data Product SDKSchemaBronze{"data_type":"","catalog_name":"","data_pack_name":"","database_name":"","dataset_name":"","table_fields":[{"name":"","nullable":true,"type":""}],"table_modifiers":[""],"table_name":"","table_owner":"","table_properties":{"":""},"table_selectors":[""]}
Package: cortex-deploy
Cortex makes it simple to deploy machine learning models in production.DeployDeploy TensorFlow, PyTorch, ONNX, scikit-learn, and other models.Define preprocessing and postprocessing steps in Python.Configure APIs as realtime or batch.Deploy multiple models per API.ManageMonitor API performance and track predictions.Update APIs with no downtime.Stream logs from APIs.Perform A/B tests.ScaleTest locally, scale on your AWS account.Autoscale to handle production traffic.Reduce cost with spot instances.documentation•tutorial•examples•chat with usInstall the CLIpipinstallcortexYou must haveDockerinstalled to run Cortex locally or to create a cluster on AWS.Deploy an example# clone the Cortex repositorygitclone-bmasterhttps://github.com/cortexlabs/cortex.gitUsing the CLI# deploy the model as a realtime apicortexdeploycortex/examples/pytorch/text-generator/cortex.yaml# view the status of the apicortexget--watch# stream logs from the apicortexlogstext-generator# get the api's endpointcortexgettext-generator# generate textcurl<APIendpoint>\-XPOST-H"Content-Type: application/json"\-d'{"text": "machine learning is"}'\# delete the apicortexdeletetext-generatorIn Pythonimportcorteximportrequestslocal_client=cortex.client("local")# deploy the model as a realtime api and wait for it to become activedeployments=local_client.deploy("cortex/examples/pytorch/text-generator/cortex.yaml",wait=True)# get the api's endpointurl=deployments[0]["api"]["endpoint"]# generate textprint(requests.post(url,json={"text":"machine learning is"}).text)# delete the apilocal_client.delete_api("text-generator")Running at scale on AWSRun the command below to create a cluster with basic configuration, or seecluster configurationto learn how you can customize your cluster withcluster.yaml.SeeEC2 instancesfor an overview of several EC2 instance types. To use GPU nodes, you may need to subscribe to theEKS-optimized AMI with GPU Supportandfile an AWS support ticketto increase the limit for your desired instance type.# create a Cortex cluster on your AWS accountcortexclusterup# set the default CLI environment (optional)cortexenvdefaultawsYou can now run the same commands shown above to deploy the text generator to AWS (if you didn't set the default CLI environment, add--env awsto thecortexcommands).
Package: cortexflow
Bayesian Linear Regression with Hamiltonian Monte Carlo (HMC)This repository contains code for performing Bayesian Linear Regression using Hamiltonian Monte Carlo (HMC) sampling. Bayesian Linear Regression is a probabilistic approach to regression modeling that provides uncertainty estimates for the model parameters. HMC is a Markov Chain Monte Carlo (MCMC) method that uses Hamiltonian dynamics to generate samples from the posterior distribution.OverviewBayesian Linear Regression with HMC combines the flexibility of Bayesian modeling with the efficiency of HMC sampling to estimate the posterior distribution of regression coefficients. This allows for principled uncertainty quantification and robust inference in regression tasks.How to UseTo use Bayesian Linear Regression with HMC, follow these steps:Prepare Your Data: Ensure your input featuresXand target variableyare in the appropriate format.Xshould be a 2D numpy array where each row represents a sample and each column represents a feature.yshould be a 1D numpy array containing the corresponding target values.Instantiate the Model: Create an instance of theBayesianLinearRegressionclass.Perform Regression: Call thehamiltonian_monte_carlomethod of the model instance, passing your data and desired parameters such as the number of samples (num_samples) and leapfrog steps (L).Analyze Results: Analyze the posterior samples obtained from the regression to make predictions, compute metrics, and assess uncertainty.Theoretical DetailsBayesian Linear Regression: Bayesian Linear Regression is a probabilistic approach to regression modeling that treats the regression coefficients as random variables and estimates their posterior distribution using Bayes' theorem.Hamiltonian Monte Carlo (HMC): HMC is a Markov Chain Monte Carlo (MCMC) method that simulates Hamiltonian dynamics to sample from complex probability distributions. It employs a "Hamiltonian" function that combines the potential energy (negative log-posterior) and kinetic energy to guide the exploration of the parameter space.RequirementsPython 3.xNumPySciPyReferencesNeal, R. M. (2011). MCMC using Hamiltonian dynamics. Handbook of Markov Chain Monte Carlo, 2(11), 2.Gelman, A., Carlin, J. B., Stern, H. S., Dunson, D. B., Vehtari, A., & Rubin, D. B. (2013). Bayesian Data Analysis (3rd ed.). Chapman and Hall/CRC.LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details.
Package: cortexpy
testspackagedocsCortexpy is a Python package for sequence analysis using linked and colored De Bruijn graphs such as
the ones created byCortexandMccortex.
This project aims to mirror many of the features contained inCortexJDK.Cortexpy also comes with a command-line tool for basic inspection and manipulation of Cortex graphs with and without links.AudienceThe audience of cortexpy is researchers working with colored De Bruijn graphs and link information inCortexandMccortexformat.Free softwareCortexpy is free software; you can redistribute it and/or modify it under the
terms of the Apache License version 2.0.  Contributions are welcome. Please join us onGitHub.Installationpip install cortexpyDocumentationFor more information, please see cortexpydocumentation.Citing cortexpyIf you use cortexpy in your work, please consider citing:Akhter, Shirin, Warren W. Kretzschmar, Veronika Nordal, Nicolas Delhomme, Nathaniel R. Street, Ove Nilsson, Olof Emanuelsson, and Jens F. Sundström. “Integrative analysis of three RNA sequencing methods identifies mutually exclusive exons of MADS-box isoforms during early bud development inPicea abies.”Frontiers in Plant Science9 (2018).https://doi.org/10.3389/fpls.2018.01625BugsThis code is maintained by Warren Kretzschmar <winni@warrenwk.com>.
For bugs, please raise aGitHub issue.DevelopmentInstallconda.Download mccortex for testing:conda env create -f environment.yml -n my-dev-environmentActivate development environment:conda activate my-dev-environmentInstall remaining development tools:pip3 install -r requirements.txtAll remaining commands in the development section need to be run in an activated
conda dev environment.Testsmake testDeploy new cortexpy version to pypiRequires access credentials for pypi.make deployBuilding the docsThe documentation is automatically built by read-the-docs on push to master.
To build the documentation manually:# install sphinx dependencies
pip install -r docs/requirements.txt

make docs
Package: cortex-python-builders
Programmatic Building of Cortex ResourcesThe Cortex Python Builders module provides tools to programmatically build Cortex resources (e.g. Skill, Actions, Datasets, etc.) using Python.
Refer to the Cortex documentation for details on how to use the library:Developer guide:https://docs.cortex.insights.ai/docs/developer-guide/overview/Cortex Python references:https://docs.cortex.insights.ai/docs/developer-guide/reference-guidesInstallationTo install:> pip install cortex-python-buildersor from source code:> git clone git@github.com:CognitiveScale/cortex-python-builders.git
  > cd cortex-python-builders
  > pip install -e .DevelopmentSetupWhen developing, it's a best practice to work in a virtual environment. Create and activate a virtual environment:> virtualenv --python=python3.6 _venv
  > source _venv/bin/activateInstall developer dependencies:> git clone git@github.com:CognitiveScale/cortex-python-builders.git
  > cd cortex-python-builders
  > make dev.installThere's a convenienceMakefilethat has commands to common tasks, such as build, test, etc. Use it!TestingUnit TestsFollow above setup instructions (making sure to be in the virtual environment and having the necessary dependencies)make testto run test suiteTo run an individual file or class method, use pytest. Example tests shown below:file:pytest test/unit/ames_test.pyclass method:pytest test/unit/ames_test.py::TestLocal::test_analysisPublishing an alpha buildSuppose you want to release new functionality so it can be installed without releasing a new official version. We need to use an alpha version in PyPi.we need to create and publish an alpha release:get credentials to thecortex-python-builderspypi CognitiveScale account (via lastpass)runmake dev.push. The alpha pre-release number (the N in X.Y.ZaN) with be determined automatically.ContributionAfter contributing to the library, and before you submit changes as a PR, please do the followingRun unit tests viamake testManual verification (i.e. try the new changes out in Cortex) to make sure everything is going well. Not required, but highly encouraged.Bump upsetup.pyversion and update theCHANGELOG.mdDocumentationActivate your virtual environment:> source _venv/bin/activateSetup your environment, if you have not done so:> make dev.installThe package documentation is built with Sphinx and generates versioned documentation for all tag matching therelease/X.Y.Zpattern and for themasterbranch. To build the documentation:> make docs.multiThe documentation will be rendered in HTML format under thedocs/_build/${VERSION}directory.Pre-release to stagingCreate and push an alpha release:> make dev.push TAG=1This will build an alpha-tagged package.Mergedeveloptostagingbranch:> make stageIn GitHub, create a pull request fromstagingtomaster.
Package: cortex-python-profiles
Profile of 1 Extension for the Base Python Module of the Cortex Cognitive Platform[cortex-python][https://github.com/CognitiveScale/cortex-python]
The Cortex Python Profiles module extends theBase Python Module of the Cortex Cognitive Platformwith Profile of 1 related functionality.Refer to the Cortex documentation for details on how to use the library:Developer guide:https://docs.cortex.insights.ai/docs/developer-guide/overview/Cortex Python references:https://docs.cortex.insights.ai/docs/developer-guide/reference-guidesInstallationTo install:> pip install cortex-python-profilesor from source code:> git clone git@github.com:CognitiveScale/cortex-python-profiles.git
  > cd cortex-python-profiles
  > pip install -e .DevelopmentSetupWhen developing, it's a best practice to work in a virtual environment. Create and activate a virtual environment:> virtualenv --python=python3.6 _venv
  > source _venv/bin/activateInstall developer dependencies:> git clone git@github.com:CognitiveScale/cortex-python-profiles.git
  > cd cortex-python-profiles
  > make dev.installThere's a convenienceMakefilethat has commands to common tasks, such as build, test, etc. Use it!TestingUnit TestsFollow above setup instructions (making sure to be in the virtual environment and having the necessary dependencies)make testto run test suiteTo run an individual file or class method, use pytest. Example tests shown below:file:pytest test/unit/agent_test.pyclass method:pytest test/unit/agent_test.py::TestAgent::test_get_agentPublishing an alpha buildSuppose you want to release new functionality so it can be installed without releasing a new official version. We need to use an alpha version in PyPi.we need to create and publish an alpha release:get credentials to thecortex-pythonpypi CognitiveScale account (via lastpass)runmake dev.push TAG=<alpha release number>. Example:make dev.push TAG=1ContributionAfter contributing to the library, and before you submit changes as a PR, please do the followingRun unit tests viamake testManually verification (i.e. try the new changes out in Cortex) to make sure everything is going well. Not required, but highly encouraged.Bump upsetup.pyversion and update theCHANGELOG.mdDocumentationActivate your virtual environment:> source _venv/bin/activateSetup your environment, if you have not done so:> make dev.installThe package documentation is built with Sphinx and generates versioned documentation for all tag matching therelease/X.Y.Zpattern and for themasterbranch. To build the documentation:> make docs.multiThe documentation will be rendered in HTML format under thedocs/_build/${VERSION}directory.Pre-release to stagingCreate and push an alpha release:> make dev.push TAG=1WhereTAGis the alpha version number. This will build an alpha-tagged package.Mergedeveloptostagingbranch:> make stageIn GitHub, create a pull request fromstagingtomaster.
Package: cortex-xdr-client
A python-based API client forCortex XDR
API.Currently, it supports the following Cortex XDRPrevent & ProAPIs:Alerts API:Get AlertsDownloads API:Download FileEndpoints API:Get All EndpointsGet EndpointIsolate EndpointsUnisolate EndpointsScan EndpointsRetrieve FileQuarantine FileIncidents API:Get IncidentsGet Extra Incident DataIndicators API:Insert Simple Indicators JSONResponse Actions API:Get Action StatusScripts API:Get ScriptsGet Script MetadataGet Script Execution StatusGet Script Execution ResultsGet Script Execution Result FilesRun ScriptRun Snippet Code ScriptXQL API:Start XQLGet XQL ResultsGet XQL Result StreamContributing:SeeCONTRIBUTING.mdfor details.
Package: cortix
CortixA Python library for network dynamics modeling and HPC simulation.Cortix on Jupyter notebook examplesDocumentation on the webWhat is Cortix?Cortix is a massively parallel Python library for system-level module coupling, execution, and
analysis of dynamical system models that exchange time-dependent data.Cortix takes as input a collection of computational modules and provides an
environment for the coupling of these modules into a single simulation.Cortix supports:Module decouplingCommunication between modulesData visualizationCortix runs on top ofMPIand scales across many cores.Installation: start by installingMPIInstalling via PyPIpip install --user cortixInstalling from sourceClone this repository to install the latest version of Cortixgit clone https://github.com/dpploy/cortix.gitInstall the required dependencies listed inrequirements.txtpip install --user -r cortix/requirements.txtAddcortix's parent path to your$PYTHONPATHvariableexport PYTHONPATH=$PYTHONPATH:$(pwd)Note: you may want to add this line to your.bashrcin order for it to be persistentVerify your Cortix install by running the Droplet examplempirun -np 12 examples/droplet_run.pyTestingTesting is facilitated byPyTest. Tests can be run locally from within thetestsdirectorycd tests && py.testUsing CortixPlease refer to thedocumentationfor more on getting started!TeamValmor F. de Almeida:valmor_dealmeida@uml.eduTaha M. Azzaoui:tazzaoui@cs.uml.eduSeamus D. Gallagher:seamus_gallagher@student.uml.eduAustin Rotker:austin_rotker@student.uml.eduGilberto E. Alas:gilberto_alas@student.uml.eduContributingPull requests are welcome. For major changes, please open anissuefirst to discuss what you would like to change.Please make sure to update tests as appropriate.LocationCortix Groupc/oUMass Innovation Hub110 Canal St., 3rd FloorLowell, MA  01852
Package: cortx-pytorch
cortx_pytorchFast interface between pytorch and Segate CORTXThis package let you encode and upload a pytorch computer vision dataset (of the shape (image,label)) to CORTX.1: Installpip install cortx_pytorch2: Convert and upload your datasetfromcortx_pytorchimportupload_cv_dataset,make_clientfromtorchvisionimportdatasetsif__name__=='__main__':# Define the connection settings for our clientclient=make_client(URL,ACCESS_KEY,SECRET_KEY)bucket='testbucket'# Bucket where to read/write our ML datasetfolder='imagenet-val'# Folder where this particular dataset will be# We use a pytorch dataset as a source to prime the content of CORTX# Once we have encoded and uploaded it we don't need it anymore# Here we use a locally available Imagenet datasetds=ds=datasets.ImageFolder('/scratch/datasets/imagenet-pytorch/val')# Packs and upload any computer vision dataset on cortx## It only needs to be done once !# Image are groupped in objects of size at most `masize` and at most# `maxcount` images. We use `workers` processes to prepare the data# in parallelupload_cv_dataset(ds,client=client,bucket=bucket,base_folder=folder,maxsize=1e8,maxcount=100000,workers=302: Use the dataset like any pytorch datasetfimporttorchaschfromtqdmimporttqdmfromcortx_pytorchimportRemoteDataset,make_clientfromtorchvisionimporttransformspreproc=transforms.Compose([transforms.RandomResizedCrop(224),transforms.RandomHorizontalFlip(),transforms.ToTensor(),])if__name__=='__main__':# Define the connection settings for our clientclient=make_client(URL,ACCESS_KEY,SECRET_KEY)bucket='testbucket'# Bucket where to read/write our ML datasetfolder='imagenet-val'# Folder where this particular dataset will be# Now that we have created and upload the dataset on CORTX we can use# it in Pytorchdataset=(RemoteDataset(client,bucket,folder).decode("pil")# Decode the data as PIL images.to_tuple("jpg;png","cls")# Extract images and labels from the dataset.map_tuple(preproc,lambdax:x)# Apply data augmentations.batched(64)# Make batches of 64 images)# We create a regular pytorch data loader as we would do for regular data setsdataloader=ch.utils.data.DataLoader(dataset,num_workers=3,batch_size=None)forimage,labelintqdm((xforxindataloader),total=100000/60):# Train / evaluate ML models on this batch of datapass