semvec/pypi-packages huggingface dataset:
resource-generator 0.1.7
Python CLI for generate resource such as model, controller, service, schema and repository
Requires Python: <4.0,>=3.10

# Resource Generator For FastApi
___
**Source Code:** [https://github.com/RatanaKH/resource_generator](https://github.com/RatanaKH/resource_generator)

## Overview
A `generate` command for a FastAPI project simplifies the creation of common components like models, controllers, services, and schemas. It acts as a code scaffolding tool, ensuring consistent structure, reducing boilerplate, and accelerating development.

### Key Reasons for Creating a generate Command
1. Consistency Across the Codebase:
Enforcing a consistent naming convention and folder structure.
Preventing errors caused by manual file creation and misplaced code.
Ensuring that all components follow best practices and are aligned with project standards.

1. Improved Developer Productivity:
Automating repetitive tasks like creating models, schemas, and services.
Reducing time spent writing boilerplate code for new components.
Allowing developers to focus on business logic instead of setup tasks.

1. Scalability for Large Teams:
Standardizing the creation process for teams to minimize onboarding effort.
Reducing human errors and misunderstandings regarding file and module organization.
Making collaboration smoother by enforcing project guidelines automatically.

1. Maintainability:
Encouraging modular and predictable code organization.
Generating components with pre-defined templates ensures maintainable and testable code.
Easy refactoring and debugging, as all components are structured consistently.


## Installation

To install this package, use pip:

```bash
  pip install resource-generator
```

To install this package, use poetry:
````shell
  poetry add resource-generator
````

## How to use command

````shell
  ratana-pls make-[OPTION] name [FILE_NAME]
````

### Example:
```shell
  ratana-pls make-model name Users
  
  # Generate model and Users Controller
  ratana-pls make-model name Users --controller 
  
  # Generate model and Users Service
  ratana-pls make-model name Users --service
  
  # Generate model and Users Schema
  ratana-pls make-model name Users --schema 
  
  # Generate model and Users Repository
  ratana-pls make-model name Users --repository 
```
```shell
  ratana-pls make-controller name Users
```
```shell
  ratana-pls make-repository name Users
```
```shell
  ratana-pls make-schema name Users
```
```shell
  ratana-pls make-service name Users
```



#### Sample project structure
```
Project-Name
├── app
│   ├── controllers
│   ├── services
│   ├── models
│   ├── schemas
│   ├── repository
│   ├── router.py
│   ├── main.py
├── poetry.lock
├── package.json
├── pyproject.toml
└── .gitignore
```

___

This package is built on the [typer](https://github.com/fastapi/typer) library.
rythreadpool 1.0.0
Multi-threading library
Requires Python: >=3.8

# ThreadPool library
- Multi-threading library 
- Allows to limit the number of threads to a fixed number

## Install
```
pip install rythreapool
```

## Usage
- import the library
```python
import threadpool
```
- create a new ThreadPool, giving as argument the number of desidred parallel threads
  - it is suggested to never exceed the number of physical threads that your processor has
```python
pool = threadpool.ThreadPool(16)
```
- now it is possible to run multiple functions or tasks 
```python
pool.execute(fn=myTask, args=())
```
- to check if the threadpool is busy, use the following function
  - returns `True` if the pool is working, otherwise returns `False`
```python
pool.isWorking()
```

### Notes
1. remember that, if a task implements active waiting, it will keep its thread busy until the end of execution
2. once reaced the limit of parallel threads, all the following tasks will have to wait for a thread to become free
runno 0.2.1
Run untrusted code inside the Runno WebAssembly sandbox.
Requires Python: >=3.13

# runno

Package for running code inside the Runno WebAssembly sandbox.

## Quickstart

The `run_code` method allows you to run a snippet of code.

```python
from runno import run_code

code = "print('Hello, World!')"
result = await run_code("python", code)

if result.result_type == "complete":
    print("OUTPUT:")
    print(result.tty)
else:
    print("ERROR")
```

Available runtimes are: `python`, `quickjs`, `sqlite`, `clang`, `clangpp`, `ruby`, and `php-cgi`.

## Including Files

If you want to process files within your sandbox, you can include them in the
file system by using the `run_fs` method.

```python
from runno import run_fs, WASIFS, StringFile, WASITimestamps

fs: WASIFS = {
    "/program.py": StringFile(
        path="/program.py",
        timestamps=WASITimestamps(
            access=datetime.now(),
            modification=datetime.now(),
            change=datetime.now(),
        ),
        mode="string",
        content="""
print(open('data.csv'))
""",
    ),
    "/data.csv": StringFile(
        path="/data.csv",
        timestamps=WASITimestamps(
            access=datetime.now(),
            modification=datetime.now(),
            change=datetime.now(),
        ),
        mode="string",
        content="""
a,b,c
1,2,3
""",
    )
}

await run_fs(runtime, "/program", fs)
```

## Including Dependencies

You can use the same technique to include pure python packages as dependencies.
The interface for this is not super nice right now, but it's on the way.

## Limiting Execution Time

You can limit how much time is allocated for execution using an optional
`timeout` kwarg (measured in seconds). Like:

```python
from runno import run_code

code = "while True: pass"
result = await run_code("python", code, timeout=5)

if result.result_type == "timeout":
    print("Timed out.")
else:
    print("Wow, it ran forever.")
```
s2-sdk-python 0.1.0
Add your description here
Requires Python: >=3.11

# streamstore

`streamstore` is the Python package that provides an async client for interacting with the [gRPC API](https://s2.dev/docs/interface/grpc) of [S2, the Stream Store](https://s2.dev/).

## Installation

You can install the package from the [Python Package Index](https://pypi.org/) using the package manager of your choice. E.g., with `pip`:

```bash
pip install streamstore
```

If you are managing the dependencies of your project through [uv](https://docs.astral.sh/uv/concepts/projects/dependencies/#managing-dependencies):
```bash
uv add streamstore
```

## Requirements

Python >= 3.11
vp-models 1.0.2
A package for machine learning models and utilities
Requires Python: >=3.7

*Vp_models* is a Python package for machine learning models and utilities. It includes a set of models like linear regression and other machine learning algorithms, along with utility functions for data preprocessing and model evaluation.

##Installation

You can install the package via pip:

pip install vp_models==0.1.0

### Usage
##Importing Models
Once installed, you can import the models and utilities from the package.

````python
#Import the Linear Regression model
from vp_models.models.linear_regression import LinearRegression


```