semvec/pypi-packages huggingface dataset:
findCPcore 0.1.1
findCP core package
Requires Python: >=3.5

[![PyPI version](https://badge.fury.io/py/findCPcore.svg)](https://badge.fury.io/py/findCPcore) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![CI-CD](https://github.com/findCP/findCPcore/actions/workflows/main.yml/badge.svg)](https://github.com/findCP/findCPcore/actions/workflows/main.yml) [![Documentation Status](https://readthedocs.org/projects/findcpcore/badge/?version=latest)](https://findcpcore.readthedocs.io/en/latest/?badge=latest)		
[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg)](https://github.com/RichardLitt/standard-readme) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/findCP/findCPcore/HEAD?filepath=docs%2Fsource%2FCORE.ipynb) [![DOI](https://zenodo.org/badge/254950974.svg)](https://zenodo.org/badge/latestdoi/254950974)




## findCPcore - find ChokePoint reactions in genome-scale metabolic models

```findCPcore``` is a Python tool for the computation of chokepoint reactions in genome-scale metabolic models. The tool allows the calculation of chokepoints taking into account only the topology of the metabolic network or also using its dynamic information.

The documentation can be found at [readthedocs](https://findcpcore.readthedocs.io/en/latest/) and can also be [downloaded](https://findcpcore.readthedocs.io/_/downloads/en/latest/pdf/).

A command line application of the tool is provided at [findCPcli](https://github.com/findCP/findCPcli).

You can also [try it with Binder](https://mybinder.org/v2/gh/findCP/findCPcore/HEAD?filepath=docs%2Fsource%2FCORE.ipynb).

For citation purposes please refer to:

Oarga et al. "Growth Dependent Computation of Chokepoints in Metabolic Networks." International Conference on Computational Methods in Systems Biology. Springer, Cham, 2020. https://doi.org/10.1007/978-3-030-60327-4_6

## Table of Contents
- [Install](#install)
- [Maintainers](#maintainers)
- [Contributing](#contributing)
- [License](#license)

## Install

```sh
$ pip install findCPcore
```

## Quickstart

Example of network refinement and chokepoint computation:

```python
from findCPcore import CobraMetabolicModel

model = CobraMetabolicModel("aureus.xml")

# update flux bounds with FVA
model.fva(update_flux=True)

# compute chokepoints
model.find_chokepoints()

# get chokepoints
model.chokepoints()
```

## Maintainers

[@alexOarga](https://github.com/alexOarga)

## Contributing

Feel free to dive in! [Open an issue](https://github.com/findCP/findCPcore/issues) or submit PRs.

Standard Readme follows the [Contributor Covenant](http://contributor-covenant.org/version/1/3/0/) Code of Conduct.

## License

[GPL](LICENSE) © Alex Oarga
pyp3 1.0.0
Pyp is a linux command line text manipulation tool similar to awk or sed, but which uses standard python string and list methods as well as custom functions evolved to generate fast results in an intense production environment.
Requires Python: >=3.0

# pyp3

A minified [pyp](https://code.google.com/archive/p/pyp/) compatible with python3

Pyp is a linux command line text manipulation tool similar to awk or sed, but which uses standard python string and list methods as well as custom functions evolved to generate fast results in an intense production environment.

## Installation

### From PyPI

```sh
pip3 install pyp3
```

### From GitHub

```sh
pip3 install git+https://github.com/donno2048/pyp3
```

## Usage

Because pyp employs it's own internal piping syntax ("|") similar to unix pipes, complex operations can be proceduralized by feeding the output of one python command to the input of the next.

This greatly simplifies the generation and troubleshooting of multistep operations without the use of temporary variables or nested parentheses. The variable "p" represents each line as a string, while "pp" is entire input as python list

### Use it directly

```sh
ls | pyp3 "p[0] | pp.sort()" #gives sorted list of first letters of every line
```

## Use it as a python module

```sh
ls | python3 -m pyp3 "p.replace('.', ',')" #replaces . with ,
```
Donut3d 0.111
3d ASCII Donut3d in python

Python module for creating flying 3d donut from ASCII symbols

#How to use:

1. Import module \
```from Donut3d import Donut```
2. Create Donut object \
```d = Donut([screen_size = 40,] [framerate = 60,] [theta_spacing = 0.07,] [phi_spacing = 0.02])```
3. Run rendering \
```d.run()```
pl-minio-callback 1.0.4
Callback prepared to log checkpoints to minio server.
Requires Python: >=3.6

# Pytorch Lightning Minio Callback

Callback prepared to log checkpoints and tensorboard data to minio server.

## Minimum Requirements
Python 3.6 or higher.

## Download using pip

```sh
pip3 install pl-minio-callback
```

## Download source

```sh
git clone https://github.com/dpulpeiro/pl-minio-callback
cd pl-minio-callback
python setup.py install
```

## Quick Start Example

This example shows how to use the class MinioCallback to upload checkpoints to minio server.

###
You can use this [docker-compose](https://github.com/dpulpeiro/pl-minio-callback/blob/master/docker/docker-compose.yaml) 
to launch a minio instance with only one volume in the ports 9000 and 9001 with user 'minio' and password 'minio123'

| Parameters              | Description                                                   |
|-------------------------|---------------------------------------------------------------|
| save_dir                | Directory to save models in.                                  |
| name                    | Sub-directory to save models in.                              |
| upload_models           | Whether to upload the checkpoints or not                      |
| upload_hparams          | Whether to upload the hparams or not                          |
| upload_tensorboard_data | Whether to upload tensorboard data  or not                    |
| bucket                  | Name of the bucket where data will be stored                  |
| endpoint                | URL to minio service.                                         |
| endpoint                | URL to minio service.                                         |
| access_key              | Access key (aka user ID) of an account in the minio service.  |
| secret_key              | Secret key (aka password) of an account in the minio service. |
| secure                  | Whether endpoint uses https or not.                           |
| secure                  | Whether endpoint uses https or not.                           |

Files will be saved in disk with the following file structure
```
    <save_dir>/<name>/version_x/checkpoints_and_tensorboard_data
```
They will also be uploaded to minio:
```
    <bucket>/<save_dir>/<name>/version_x/checkpoints_and_tensorboard_data
```
### Usage

```py
...
from pl_minio_callback.minio_callback import MinioCallback

...
if __name__ == "__main__":
    ...
    logger = TensorBoardLogger(save_dir="models", name="cifar10_resnet")  # Check parameters
    trainer = pl.Trainer(
        callbacks=[
            MinioCallback(
                upload_tensorboard_data=False,
                upload_hparams=False,
                upload_checkpoints=True,
                bucket="tensorboard",
                endpoint="localhost:9000",
                access_key="minio",
                secret_key="minio123",
                secure=False
            )
        ],
        log_every_n_steps=5,
        checkpoint_callback=True,
        logger=logger,
        max_epochs=10,
        gpus=1,
        auto_select_gpus=True
    )
    ...

```