semvec/pypi-packages huggingface dataset:
text-token 0.9.0b1
Tokenization of user text.
Requires Python: >=3.11

# text-token
Tokenization of user strings.

[![codecov](https://codecov.io/gh/Shapedsundew9/text-token/graph/badge.svg?token=GESHT01VMT)](https://codecov.io/gh/Shapedsundew9/text-token)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)
[![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)


## Sunburst Code Coverage Chart

 The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
 ![Sunburst](https://codecov.io/gh/Shapedsundew9/text-token/graphs/sunburst.svg?token=GESHT01VMT)
pdengine 0.0.6
Process Dynamics Engine
Requires Python: >=3.7

# PDEngine - Process Dynamics Engine

Process Dynamics Engine (PDEngine) is an online, iterative simulator for process control models described by transfer functions or state space representations. PDE is implemented in Python and uses the [Python Control Systems Library](https://github.com/python-control/python-control). Users can interact with the simulation by using an API to send control actions (e.g. increasing a reflux rate or shutting off a valve) and query process variables like temperature and pressure. PDE is intended to be an educational tool in chemical engineering process control courses.

## Usage

Models are defined by inheriting from the `Model` parent class. An example using the Wood-Berry distillation model (3 inputs - 2 MVs, 1 FF & 2 outputs) is provided in `/src/WoodBerryModel.py`.

A PDEngine Model must include:
- Name (e.g. Wood-Berry Distillation)
- Input names (e.g. $R$ - Reflux flow rate, $S$ - Steam flow rate, $F$ - Feed flow rate)
- Ouput names (e.g. $X_D$ - top composition, $X_B$ - bottom composition)
- Steady-state values for inputs and outputs
- Validity limits for inputs and outputs
- Typical moves for inputs

A driver program is then created to set up the simulation and initialize the model. Users must define:

- The simulation step size, $dt$
- Simulation speed, in terms of a time delay, $T_D$ between steps

```
wm = WoodBerryModel()
dt=0.02 # in minutes, for the Wood-Berry model
woodberry = wm.create_system(dt=dt) # make the actual generator with step size = 0.02
```

At each iteration of the simulation, users can send values to the simulation by using `send()` with a dictionary with the Input names as keys:

```
# the main engine loop
for i in range(N):        
    y = woodberry.send({'R': 0.01, 'S': 0.01, 'F': 0.05}) # send this value to the model
    time.sleep(0.001) # this is the time delay T_D for the simulation speed
```

An example driver program is provided in the `Example.ipynb` notebook that uses the Wood-Berry distillation example.

## Development

Recommended environment setup:

```
conda create -n pdengine python=3.10
conda activate pdengine
conda install -c conda-forge ipykernel slycot
python -m pip install control jupyter
python -m ipykernel install --user --name=pdengine
```

For an editable development environment, navigate to the `pd-engine` folder, then run:

```
python -m pip install -e .
```

If everything is working correctly, you should be able to run the example notebooks.
request-miner 0.0.1
A simple requests wrapper with backoff.
Requires Python: >=3.7

# Request Miner

A tool that enables you to automatically request and retry failing requests for a certain amount of times.
This tool is built on top of: `requests` and `backoff`, which this package relies on.

## Installation

```bash
pip install request-miner
```

## Usage

To create a request without passing a session:

```python
from request_miner import mine
from requests.exceptions import RequestException

get_req = mine(method="GET", url="https://www.google.com")
post_req = mine(
    method="POST",
    url="https://www.google.com",
    json={"key": "value"},
    backoff_type = "expo", # default is constant, but you can override with existing backoff functions or your own
    max_tries = 3, # max tries of a single request
    max_time = 10, # max time of a request
    exception = RequestException, # exception types that can be handled
    raise_on_giveup = True # if you want to raise the exception on giveup
) # This request will fail 
```

To create a prepared request with a session:

```python
import requests

from requests import Request, Session
from request_miner import process_request
from requests.exceptions import RequestException

session = requests.Session()
get_req = Request(method="GET", url="https://www.google.com").prepare()
process_request(
    get_req,
    session,
    backoff_type = "expo", # default is constant, but you can override with existing backoff functions or your own
    max_tries = 3, # max tries of a single request
    max_time = 10, # max time of a request
    exception = RequestException, # exception types that can be handled
    raise_on_giveup = True # if you want to raise the exception on giveup
)
```
constellatus 0.0.2
Elder data composition
Requires Python: >=3.7

 # Constellatus

Constellatus is an extension of the Eons APIE executable. It provides a RESTful API for storing, retrieving, and optimizing code written within the Eons framework.

**Our goal is to automate the process of translation.**  
By refining our code for us, Constellatus allows us make succinct statements that are easy for others to use.  

We make heavy use of astronomy metaphors.

## Overview
* `Stars` are fully formed `SelfRegistering` classes.
* We measure the mass of code by its behavior. Well structured, well performing, easily repeatable behavior results in higher mass (e.g. one program has a deeper gravity well than another that does the same thing but is slower).
* We model matter as the quantity of code, regardless of its behavior.
* The "density" of a particular bit of code is measured by how well it behaves over how much code it contains.
* The Eons Error Resolution machinery (EER) is our corollary to nuclear fusion: it takes code that is not well behaved but could be (i.e. low mass) and improves its behavior, increasing its gravitational force and thus its mass.

To illustrate what "could be well behaved" means, imagine code which operates perfectly but is missing context, e.g. requires an additional include statement or a package to be installed. These kinds of errors, which are trivial to resolve, provide the fuel for the EER machinery. This is useful as it allows us as programmers to write only what is necessary, and have all dependencies automatically injected. 

## Stars
The minimum requirement for a SelfRegistering class to be a Star is that it possess enough well behaved code such that it requires no interaction with the Eons Error Resolution machinery to be instantiated.
Stars may progress through a normal lifecycle of improvements, whereby they become increasingly dense. This process is similar to how a user might implement Cython: small, well behaved units of the Star are replaced with code from Biology, C++, C, or Assembly. Code that is not well behaved is refined through repeated application of the Eons Error Resolution machinery.
A Star's lifecycle is entirely managed by Constellatus. Stars may be Formed and Destroyed but their updates are entirely automated.
They key to making Constellatus work is the continual rewrite of the code of Stars so that each time it's Observed, it becomes more compact.


## Installation
```
pip install constellatus
```

## Usage
For now, refer to [Apie](https://github.com/eons-dev/apie.exe) for all configuration.

When running as a webserver, the default port is 1137, after the approximation for the [fine structure constant](https://en.wikipedia.org/wiki/Fine-structure_constant): 1/137.
jellyserve 0.2.0
simple python web framework with support for .svelte files
Requires Python: >=3.10

# JellyServe

JellyServe is a simple and flexible web framework written in Python with native support for .svelte files.

What works?
* Routing (dynamic routes, matchers, etc.)
* Svelte file compilation and population
* Simple database integration (alpha)
* Messages (simpler websockets)

What does not work/is planned?
* Testing utility
* Wiki through GitHub Wikis

The code is spaghetti. But it works. Maybe i will rewrite it in the future.