semvec/pypi-packages huggingface dataset:
bioreactor-model 0.0.8
Bioreactor-model is a Python package for bioreactor and biomass growth calculations
Requires Python: >=3.13

# Bioreactor-model
Bioreactor-model is a Python package for bioreactor and biomass growth calculations

## Installation

```bash
pip install bioreactor-model
```
## Documentation

[Documentation here](https://matrixdex.github.io/bioreactor-model)

## Classes
`calc.CellComposition()` calculates biomass formula and biomass molecular weight

`calc.BiomassEquation()` solves biomass growth equation

`bioreactor.time_to_titer()` calculates time to reach specified titer in exponential biomass growth

## Getting Started
1. Calculate biomass composition and molecular weight from dry weight values
```bash
from bioreactor_model import calc
expt = calc.CellComposition(values={'C':47,'H':4.15,'N':10,'O':31,'ash_fraction':7.85}, dry_weights=True)
print(expt.biomass_composition)		# biomass composition
print(expt.biomass_molar_weight)	# molecular weight = 25.545
```

2. Solve biomass equation with above biomass composition and gas inlet-outlet values
```bash
from bioreactor_model import calc
expt = calc.CellComposition(values={'C':47,'H':4.15,'N':10,'O':31,'ash_fraction':7.85}, dry_weights=True)
be = calc.BiomassEquation(expt.biomass_composition)
be.set_gas_io_values(79,21,10,83,7)
be.solve_biomass_equation()
print(be.biomass_equation_solution['string'])			# biomass equation string 
print(be.biomass_equation_solution['molar_coeff'])		# molar coefficients of biomass equation
print(be.biomass_equation_solution['biomass_composition'])	# biomass composition
print(be.biomass_equation_solution['rq'])			# respiratory quotient = 0.664
```

## Tutorials

See [tutorials](https://matrixdex.github.io/bioreactor-model/tutorials.html) in documentation.

See [tests/test.py](https://github.com/matrixdex/bioreactor-model/blob/main/tests/test.py) for usage.


## Future development

Scale up parameters, fed-batch yield estimation, yield coefficient calculation, gas transfer estimation, oxygen transport and uptake rates will be added soon.
txt2dataset 0.4.1
Convert text to datasets

# txt2dataset
A package for building, standardizing and validating datasets using language models. Supports the [Structured Output](https://github.com/Structured-Output) project. 

* [Get a Gemini API Key](https://ai.google.dev/gemini-api/docs/api-key)

## Models Supported
* Gemini

## Installation

```bash
pip install txt2dataset
```

## Usage

### Schema

```python
from pydantic import BaseModel
from typing import Optional, List
from datetime import datetime

class SingleDividend(BaseModel):
    dividend_per_share: float
    payment_date: Optional[datetime] = None
    record_date: Optional[datetime] = None
    stock_type_specified: Optional[str] = None

class DividendExtraction(BaseModel):
    info_found: bool
    data: List[SingleDividend] = []
```

### Entries
Entries consist of an identifier and the text to be structured.
```python
entries = [
    (0,
    """First Business Financial Services, Inc. (the "Company") issued a press release today 
    announcing that the Company's Board of Directors declared a quarterly dividend of $0.18 
    per share on April 30, 2021, unchanged compared to the last quarterly dividend per share. 
    The dividend is payable on May 24, 2021 to shareholders of record on May 10, 2021. 
    Also on July 12, 2020 there was a payable dividend of $0.15 per share to shareholders 
    of record on July 1st, 2020."""),

    (1,"""XYZ Corp declared a dividend of $0.25 per share, payable June 15, 2021 
    to shareholders of record as of June 1, 2021.""")
]
```

### Prompt
Choose a prompt such as:
```python
prompt = "Extract ALL dividend information from this text"
```

### Dataset Builder Initialization

Choose the requests per minute that work for your api key and model.

```python
builder = DatasetBuilder(
    prompt=prompt,
    schema=DividendExtraction,
    model="gemini-2.5-flash-lite",
    entries=entries,
    rpm=4000
)
```

### Build
```python
builder.build()
```

### Save
```python
builder.save('test.csv')
```

Result:

| _id | dividend_per_share | payment_date                  | record_date                   | stock_type_specified |
|-----|---------------------|-------------------------------|-------------------------------|-----------------------|
| 0   | 0.18                | 2021-05-24 00:00:00+00:00    | 2021-05-10 00:00:00+00:00    |                       |
| 0   | 0.15                | 2020-07-12 00:00:00+00:00    | 2020-07-01 00:00:00+00:00    |                       |
| 1   | 0.25                | 2021-06-15 00:00:00+00:00    | 2021-06-01 00:00:00+00:00    |                       |


## Future Features
* validate() - checks that data types are expected. Needed less, thanks to the development of pydantic.
* standardize() - standardizes data.
barbariantuw 1.0.0
'Barbarian - The Ultimate Warrior' game remake
Requires Python: >=3.10

# Barbarian - The Ultimate Warrior

Amiga 500 game remake written in Python and [PyGame CE][0].

![preview](https://codeberg.org/cthulhu/barbarian/raw/branch/master/readme/preview.png)
<video src="https://codeberg.org/cthulhu/barbarian/raw/branch/master/readme/demo.mp4"
       width="640" height="480" controls>
</video>

## Installation

### Linux
Download executable from [releases](https://codeberg.org/cthulhu/barbarian/releases).

### Windows
Download executable from [releases](https://codeberg.org/cthulhu/barbarian/releases).

### PIP
```shell
pip install barbariantuw
```
Launch:
```shell
barbariantuw
```

## Controls

* `ESC` - close window and exit

|           | Player 1             | Player 2 |
|-----------|----------------------|----------|
| **LEFT**  | `Left`, `Numpad 4`   | `J`      |
| **RIGHT** | `Right`, `Numpad 6`  | `L`      |
| **UP**    | `Up`, `Numpad 8`     | `I`      |
| **DOWN**  | `Down`, `Numpad 2`   | `K`      |
| **FIRE**  | `RShift`, `Numpad 0` | `Space`  |

## Credits

* Font "PressStart2P". Thanks very much to [CodeMan38][1] for a fonts.
  Also see [SIL OPEN FONT LICENSE Version 1.1][2]
* Thanks very much to [F.L.][3] for BASIC source code of Barbarian.

## Links

* [PyGame CE][0]
* [F.L. remakes][3]

[0]: https://pyga.me/
[1]: https://github.com/codeman38
[2]: barbariantuw/fnt/OFL.txt?raw=true
[3]: http://barbarian.1987.free.fr/indexEN.htm

## Build

Clone repo:
```shell
$ git clone https://codeberg.org/cthulhu/barbarian.git
```
Create virtual environment:
```shell
$ cd barbarian
$ python3 -m venv .venv
$ source .venv/bin/activate
```
Install dev-dependencies:
```shell
(.venv) $ pip install .[dev]
```

### PIP
Package for pypi.org:
```shell
(.venv) $ python3 -m build
```

### PygBag
WebAssembly zip-archive for itch.io:
```shell
(.venv) $ rm -rf pygbag/barbariantuw/* \
  && cp -r barbariantuw pygbag \
  && pygbag --archive pygbag
```

### Nuitka
To reduce output filesize use virtual environment with nuitka package only.
```shell
$ python3 -m venv .venv-nuitka
$ source .venv-nuitka/bin/activate
(.venv-nuitka) $ pip install .[nuitka]
```
Executable:
```shell
(.venv-nuitka) $ python3 -m build_nuitka
```

## Profiling
Memory:
```shell
(.venv) $ rm barbariantuw.bin
(.venv) $ python3 -m memray run -o barbariantuw.bin -m barbariantuw
(.venv) $ python3 -m memray flamegraph barbariantuw.bin
(.venv) $ <browser> memray-flamegraph-barbariantuw.html
```
> NOTE: memray not available on Windows

CPU:
```shell
(.venv) $ python -m cProfile -o barbariantuw.prof -m barbariantuw
(.venv) $ snakeviz barbariantuw.prof
```
somu 1.3.0
A simple high-performance implementation of the Self-Organizing Map (SOM) algorithm in Rust, exposed as a Python module.
Requires Python: >=3.8

# self-organizing-map
A high-performance implementation of the Self-Organizing Map (SOM) algorithm in Rust, exposed as a Python module. 

![image](https://raw.githubusercontent.com/ventus550/somu/refs/heads/master/demos/sphere.png)

# Installtion
This module interfaces with the [ArrayFire](https://arrayfire.org/docs/installing.htm#gsc.tab=0) library (version 3.8.0).
To ensure proper functionality, make sure the ArrayFire shared libraries are discoverable by the system. You can do this by updating your LD_LIBRARY_PATH environment variable:
```
export LD_LIBRARY_PATH=/path/to/arrayfire/lib64:$LD_LIBRARY_PATH
```

Then to install the latest version of the package from PyPI, simply run:
```
pip install somu
```

# Usage
```python
from somu import som
from numpy import random

data = random.rand(1000, 2)
som(data, (10, 10))
```

# Demo requirements
Before running the demos make sure to have the required packages installed:
```
pip install -r demos/requirements.txt
```

Shield: [![CC BY-NC 4.0][cc-by-nc-shield]][cc-by-nc]

This work is licensed under a
[Creative Commons Attribution-NonCommercial 4.0 International License][cc-by-nc].

[![CC BY-NC 4.0][cc-by-nc-image]][cc-by-nc]

[cc-by-nc]: https://creativecommons.org/licenses/by-nc/4.0/
[cc-by-nc-image]: https://licensebuttons.net/l/by-nc/4.0/88x31.png
[cc-by-nc-shield]: https://img.shields.io/badge/License-CC%20BY--NC%204.0-lightgrey.svg