semvec/pypi-packages huggingface dataset:
pyls-memestra 0.0.16
Memestra plugin for the Python Language Server

# pyls-memestra

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/QuantStack/pyls-memestra/master?urlpath=/lab/tree/binder/default_decorator_example.ipynb)

> [Memestra](https://github.com/QuantStack/memestra/) plugin for the [Python Language Server](https://github.com/python-lsp/python-lsp-server)

![screenshot](./screenshot.png)

# Installation

## From pip

`pip install pyls-memestra`

## From Mamba

`mamba install -c conda-forge pyls-memestra`

## From Conda

`conda install -c conda-forge pyls-memestra`

## From source

```bash
git clone git@github.com:QuantStack/pyls-memestra.git
cd pyls-memestra
python -m pip install -e .
```

# For a development environment

1. install dependencies

    ```
    mamba install -c conda-forge python jupyterlab nodejs python-lsp-server frilouz memestra jupyter-lsp
    ```

2. install the `jupyter-lsp` frontend extension (only for JupyterLab<3 users):

    ```bash
    jupyter labextension install @krassowski/jupyterlab-lsp           # for JupyterLab 2.x
    # jupyter labextension install @krassowski/jupyterlab-lsp@0.8.0   # for JupyterLab 1.x
    ```

3. install the `pyls-memestra` plugin

    ```bash
    python -m pip install -e .
    ```
artpop 0.1.1
Building artificial galaxies one star at a time
Requires Python: >=3.6

======
ArtPop
======
.. image:: ./docs/artpop_diagram.jpg

|CI| |pypi| |arXiv|

An engine for generating realistic mock images of **Art**\ ificial Stellar **Pop**\ ulations.

Documentation 
-------------
|Doc Status|

The code documentation is hosted on `Read the Docs <https://artpop.readthedocs.io>`_.

License
-------
|License|

``ArtPop`` is open-source software made available under the 
`MIT License <https://github.com/ArtificialStellarPopulations/ArtPop/blob/main/LICENSE>`_.

.. |CI| image:: https://github.com/ArtificialStellarPopulations/ArtPop/actions/workflows/build.yml/badge.svg
   :target: https://github.com/ArtificialStellarPopulations/ArtPop/actions/workflows/build.yml
.. |Doc Status| image:: https://readthedocs.org/projects/artpop/badge/?version=latest
   :target: https://artpop.readthedocs.io/en/latest/?badge=latest
.. |License| image:: http://img.shields.io/badge/license-MIT-blue.svg?style=flat
   :target: https://github.com/ArtificialStellarPopulations/ArtPop/blob/main/LICENSE
.. |pypi| image:: https://badge.fury.io/py/artpop.svg
   :target: https://badge.fury.io/py/artpop
.. |arXiv| image:: https://img.shields.io/badge/arXiv-2109.13943-blue
   :target: https://arxiv.org/abs/2109.13943
pyISARICBasics 1.0.4
A python package for SQLite database creation and some basic data processing
Requires Python: >=3.6, <4
Keywords: sample,setuptools,development

# pyISARICBasics

This package is intended to be a gentle introduction to the ISARIC dataset with the goal of helping researchers access and become familiar with the ISARIC dataset. 

The package is in the early stages of development and feature requests are welcomed as are new contributors. If you would like to contribute please make contact! 


# Install 
This package can be installed using pip - the package installer for Python. We suggest creating a virtual environment (using conda or otherwise). Miniconda (https://docs.conda.io/en/latest/miniconda.html) is a minimal installer for Anaconda that is suitable for this purpose. 

Once you have installed conda you will need to create a new virtual environment. The steps are as follows (but see https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html for alternatives). 

Type the following into a console window: 


	conda create -n "your_env_name" python=3.8
	
	
This will create a new conda environment with Python 3.8.

You should then activate your new environment by entering the following command: 

	conda activate "your_env_name" 
	
You then need to install pip using the following command: 
	
	conda install pip

You can then type the following command to install the package: 
		
	pip install pyISARICBasics

You can then access any pyISARICBasics functionality described in the documentation using IDE or Jupyter Notebook that is configured to use this environment. 

While the package is in early development we suggest regularly checking for updates with the following command:

	pip install pyISARICBasics --upgrade

# Documentation 

Package documentation is contained at the following link: https://kyleyoung1997.github.io/pyISARICBasics/


# Tutorial 
Once you have created a virtual environment to access the tutorial you can download the .ipynb file from this repo. 

Create a folder that contains this notebook and another folder containing the raw ISARIC data. 

You then need to navigate to your newly created folder and activate your virtual environment. To do this you need to open a console window and use the following command: 

	cd "path_to_directory" 
	
(If you're using a mac you can type cd and then drag the folder icon of your newly created folder into the terminal window to get the path) 

Then type the following command to open jupyter notebook: 

	jupyter notebook
		
Which will launch an interactive browser window. You can then open the tutorial notebook.
stacking-manual 0.1.11
manual stacking package for ML

Motivation:

Sometimes we train multiple models for different contexts in the data, for example:

- We want to build many independent linear models, for example estimating elasticity for different products

- Model input table has a block of observations with NULLS in some features, we want two (or more) independent models; for data with nulls vs without

But, as we build separate models, we have several challenges:

- It's hard to keep track of overall (combined) model performance.  Often we resort to reporting performance on models individually 

- Many MLOps performance monitoring systems - such as MLFlow - are structured to track a single model object, and having multiple independent model objects can make the interface unwieldy

- We may resort to doing training and model inference in one shot without saving the model object, since running a training pipeline, then inference pipeline requires saving and loading many models, which is hard to keep track of
 
This library helps combine models (also known as "stacking") when you want to explicitly assign the models to fit and predict on specific observations.  Currently, the sklearn stacking module does not allow for explicitly assigning models or independent model training
bisi 0.0.3
A Python based runner for docker images.
Requires Python: >=3.6.0

# bisi

Bisi (**B**uild**I**t**S**hip**I**t) is a tool to help run workloads locally and in the cloud. 
Bisi lets you define and run all your containerized resources from one file stored at the root of your project all in python.

Currently supported providers are:
 - Locally with docker
 - AWS Batch
 
# Installation

## Prerequisites 
[Docker](https://docs.docker.com/get-docker/) is required to use bisi

The awscli and credentials are required to use the AWS Batch features.

```bash
pip install awscli
aws configure
```

## Install bisi

Install bisi from [pypi](https://pypi.org/project/bisi/)

```bash
pip install bisi
```

# Quickstart

Getting started with bisi is as simple as creating a Dockerfile and a bisi_resources.py file. 

Create a clean directory.

```bash
mkdir bisi_example
cd bisi_example
```

Run the following to create an example Dockerfile.

```bash
echo 'FROM python:slim
RUN pip install numpy
ADD . /bisi
WORKDIR /bisi' > Dockerfile
```

Next define an example workload as a python script.

```bash
echo 'import numpy
print(numpy.random.rand())' > workload.py
```

Finally create a bisi_resources.py file to tell bisi about our Dockerfile and how to run our workload.

```bash
echo 'import bisi.resources as bsr

df = bsr.Dockerfile(name="bisi_example", file="Dockerfile")

bsr.Job(name="numpy_example", entrypoint="workload.py", dockerfile=df)' > bisi_resources.py
```

Now you can use bisi to build your dockerfile and run it.

```bash
bisi build
bisi run numpy_example
```

From here you are free to use bisi to run anything from data processing to deep learning training in docker!
Check out the sections below for more detailed usage.

# AWS Batch

With [AWS Batch](https://aws.amazon.com/batch/) you can run your batch workloads in the cloud at any scale and bisi makes that easy for you.
To get started follow the [AWS Batch Setup Guide](docs/aws_batch_setup.md) to stand up a minimal Batch infrastructure setup running on CPU instances.

Once you have a batch job queue, you can configure bisi to utilize your batch infrastructure to run jobs. 
Assuming you ran the quickstart guide you can run the following to update your `bisi_resources.py` file.

```bash
echo 'import bisi.resources as bsr
from bisi.resources.config import BatchJobConfig, ECRConfig

df = bsr.Dockerfile(name="bisi_example", file="Dockerfile", ecr_config=ECRConfig("bisi_example"))

bsr.Job(name="numpy_example", entrypoint="workload.py", dockerfile=df, 
        batch_config=BatchJobConfig(jobQueue="bisi-test-jq"))' > bisi_resources.py
```

This configures bisi to upload your docker image to [Amazon ECR](https://aws.amazon.com/ecr/) and tells bisi where to submit your batch job.
Next you can deploy your container and run it in batch.

```bash
bisi deploy
bisi run --provider aws numpy_example
```

At this point you can navigate to https://console.aws.amazon.com/batch/home to see your pending job. 
From there you can also navigate to the job to see the logs for the job.

# Contact

* Open an issue at https://github.com/nrfrank/bisi 
* Contact bisi1.user@gmail.com about any questions/reports.
poetry-link 0.1.6
Editable installs for packages developed with Poetry using Flit.
Requires Python: >=3.10,<4.0

# poetry-link

Poetry natively does not support editable installs (as of writing this on Jan 22, 2022). This
command makes use of the Flit backend to leverage its excellent symlink support. Relevant parts of
the Poetry configuration will by adpated such that no Flit related configuration needs to be added
to `pyproject.toml`.

This package depends on [Slam](https://pypi.org/project/slam-cli/) for the `slam link` command and
exposes it as plugin in Poetry.

### Example usage

    $ poetry link
    Discovered modules in /projects/my-package/src: my_package
    Extras to install for deps 'all': {'.none'}
    Symlinking src/my_package -> .venv/lib/python3.10/site-packages/my_package