semvec/pypi-packages huggingface dataset:
pydraulics 0.1.6
A simple package in development for open and pipe flow in hydraulics.
License: MIT
Requires Python: >=3.12

# pydraulics

pydraulics is a Python package designed to facilitate hydraulic calculations and analysis. It provides a range of functionalities for open channel flow and pipe flow calculations.

> Reinstala y usa
uv pip install -e .
pydraulics

## Features

### Open Channel Flow
- Depth Calculation: Estimate the depth of flow in open channels based on input parameters such as flow rate, channel geometry, and Manning's roughness coefficient.
- Flow Calculation: Determine the flow rate in open channels using various methods by using Manning's equation.
- Critical Flow and Critical Slope Calculation: Calculate the critical flow rate and critical slope in open channels to determine the specific conditions at which flow transitions occur.

### Pipe Flow
- Losses Calculation: Calculate the friction losses and other energy losses in pipes for different flow conditions and material roughness.
- Reynolds Number and Darcy Coefficient: Utilize a third-party package to calculate the Reynolds number and Darcy coefficient, providing valuable information about the flow regime and the hydraulic resistance of the pipe.

## Installation

To install pydraulics, you can use pip, the Python package manager. Simply run the following command:

```
pip install pydraulics
```

## Getting Started

Here's an example of how to use pydraulics for open channel and pipe flow calculations:

```python
from open_flow import TrapezoidalChannel, TriangularChannel, CircularChannel, RectangularChannel
from pipe_flow import Pipe

# Calculate friction losses in a pipe

#Example with Darcy (default)
pipe1 = Pipe(Q=10, D=0.2, e=0.005, L=100)
print(pipe1.__dict__)
#Example with azen-Williams
pipe2 = Pipe(Q=1, D=0.9, L=100, method='Hazen-Williams', C=140)
print(pipe2.__dict__)

# Calculate depth in an open channel
print(RectangularChannel(b=2, n=0.0013, So=0.0075, Q = 3.5).__dict__)
print(TrapezoidalChannel(b=2, n=0.013, So=0.0075, Q = 3.5, z=1.5).__dict__)
print(CircularChannel(D=1, n=0.013, So=0.0075, Q = 2.1).__dict__)
print(TriangularChannel(z=1.5, n=0.0013, So=0.0075, Q = 3.5).__dict__)

# Calculate flow rate in an open channel using Manning's equation
print(RectangularChannel(b=2, n=0.0013, So=0.0075, y = .1177).__dict__)
print(TrapezoidalChannel(b=2, n=0.013, So=0.0075, y = 0.426, z=1.5).__dict__)
print(CircularChannel(D=1, n=0.0013, So=0.0075, y = 0.2777).__dict__)
print(TriangularChannel(z=1.5, n=0.0013, So=0.0075, y = 0.354).__dict__)
```


## Contributing

Contributions to pydraulics are welcome! If you have any ideas, bug fixes, or new features, feel free to open an issue or submit a pull request on GitHub.

## License

pydraulics is licensed under the MIT License. See the [LICENSE](https://github.com/your-username/pydraulics/blob/main/LICENSE) file for more information.

We hope pydraulics proves to be a valuable tool for your hydraulic analysis and calculations. Happy coding!
rodrigo0000-fastapi-core-utils 1.0.2
Utility functions for FastAPI applications
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-utils

Utility functions for FastAPI applications.

## Features

- Common utility functions
- Validation helpers
- Data transformation utilities
- String manipulation
- Date/time utilities

## Installation

```bash
pip install rodrigo0000-fastapi-core-utils
```

## Usage

```python
from rodrigo0000_fastapi_core_utils import validate_email, generate_random_string

# Validate email
is_valid = validate_email("user@example.com")

# Generate random string
random_str = generate_random_string(length=32)
```

## Components

- **Validation Utils**: Email, phone, URL validation
- **String Utils**: Random string generation, slugify, etc.
- **Date Utils**: Date formatting and parsing
- **Data Utils**: Data transformation and manipulation

## Requirements

- Python >= 3.8
- Pydantic >= 2.0.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-services 1.0.2
Service layer for FastAPI with Email, Stripe, and Plan management
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-services

Service layer for FastAPI with Email, Stripe, and Plan management.

## Features

- **EmailService**: Send emails using Resend API
- **StripeService**: Stripe payment integration
- **PlanService**: Subscription plan management

## Installation

```bash
pip install rodrigo0000-fastapi-core-services
```

## Usage

```python
from rodrigo0000_fastapi_core_services import EmailService, StripeService, PlanService

# Email Service
email_service = EmailService()
await email_service.send_email(
    to="user@example.com",
    subject="Welcome",
    html="<h1>Welcome to our service</h1>"
)

# Stripe Service
stripe_service = StripeService()
payment_intent = stripe_service.create_payment_intent(amount=1000, currency="usd")

# Plan Service
plan_service = PlanService(db)
plans = plan_service.get_all_plans()
```

## Components

- **EmailService**: Email sending with Resend
  - Send transactional emails
  - Template support
  - Bulk email sending

- **StripeService**: Payment processing
  - Payment intents
  - Subscriptions
  - Customer management
  - Webhook handling

- **PlanService**: Subscription plans
  - Plan CRUD operations
  - User plan assignment
  - Plan history tracking

## Requirements

- Python >= 3.8
- FastAPI >= 0.104.0
- Stripe >= 7.0.0
- Resend >= 0.8.0
- SQLAlchemy >= 2.0.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-models 1.0.2
SQLAlchemy models for FastAPI applications
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-models

SQLAlchemy models for FastAPI applications.

## Features

- Pre-built SQLAlchemy models for common entities
- Pydantic schemas for request/response validation
- User models with authentication fields
- Plan and subscription models
- Timestamped base models

## Installation

```bash
pip install rodrigo0000-fastapi-core-models
```

## Usage

```python
from rodrigo0000_fastapi_core_models import User, Plan, UserCreate, UserResponse

# Use in your FastAPI application
from sqlalchemy.orm import Session

def create_user(db: Session, user: UserCreate):
    db_user = User(**user.dict())
    db.add(db_user)
    db.commit()
    return db_user
```

## Components

- **User Models**: User entity and schemas
- **Plan Models**: Subscription plan models
- **Base Models**: Timestamped base classes
- **Pydantic Schemas**: Request/response validation models

## Requirements

- Python >= 3.8
- SQLAlchemy >= 2.0.0
- Pydantic >= 2.0.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-middleware 1.0.2
Middleware components for FastAPI applications
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-middleware

Middleware components for FastAPI applications.

## Features

- CORS middleware configuration
- Request logging middleware
- Request tracing and ID generation
- Security headers middleware
- Error handling middleware

## Installation

```bash
pip install rodrigo0000-fastapi-core-middleware
```

## Usage

```python
from rodrigo0000_fastapi_core_middleware import setup_middleware
from fastapi import FastAPI

app = FastAPI()
setup_middleware(app)
```

## Components

- **CORS Middleware**: Cross-Origin Resource Sharing configuration
- **Logging Middleware**: Request/response logging
- **Tracing Middleware**: Request ID generation and tracking
- **Security Middleware**: Security headers (CSP, HSTS, etc.)
- **Error Handler**: Centralized error handling

## Requirements

- Python >= 3.8
- FastAPI >= 0.104.0
- Starlette >= 0.27.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-database 1.0.2
Database configuration and utilities for FastAPI with SQLAlchemy
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-database

Database configuration and utilities for FastAPI with SQLAlchemy.

## Features

- SQLAlchemy database setup and configuration
- Database session management
- Database initialization utilities
- Security utilities (JWT, password hashing)
- Repository pattern base classes

## Installation

```bash
pip install rodrigo0000-fastapi-core-database
```

## Usage

```python
from rodrigo0000_fastapi_core_database import get_db, Base, engine, init_db
from rodrigo0000_fastapi_core_database import create_access_token, verify_password

# Initialize database
init_db()

# Use in FastAPI dependencies
from fastapi import Depends
from sqlalchemy.orm import Session

@app.get("/items")
def get_items(db: Session = Depends(get_db)):
    # Your code here
    pass
```

## Components

- **Database**: SQLAlchemy engine, session, and base configuration
- **Init DB**: Database initialization and superuser creation
- **Security**: JWT token creation, password hashing, user verification
- **Repository**: Base repository pattern for database operations

## Requirements

- Python >= 3.8
- FastAPI >= 0.104.0
- SQLAlchemy >= 2.0.0
- Pydantic >= 2.0.0
- python-jose[cryptography] >= 3.3.0
- passlib[bcrypt] >= 1.7.4

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-controllers 1.0.2
Controller layer for FastAPI applications
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-controllers

Controller layer for FastAPI applications.

## Features

- Pre-built controllers for common operations
- RESTful endpoint definitions
- Consistent routing patterns
- Request/response handling

## Installation

```bash
pip install rodrigo0000-fastapi-core-controllers
```

## Usage

```python
from rodrigo0000_fastapi_core_controllers import UserController
from fastapi import FastAPI

app = FastAPI()
app.include_router(UserController.router, prefix="/api/v1/users", tags=["users"])
```

## Components

- **Base Controllers**: Common CRUD operations
- **User Controllers**: User management endpoints
- **Auth Controllers**: Authentication endpoints
- **Plan Controllers**: Subscription plan endpoints

## Requirements

- Python >= 3.8
- FastAPI >= 0.104.0
- Pydantic >= 2.0.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-config 1.0.2
Configuration, security, and repository utilities for FastAPI
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-config

Configuration, security, and repository utilities for FastAPI.

## Features

- Environment-based configuration management
- Centralized settings using Pydantic
- Security configuration
- Repository pattern utilities

## Installation

```bash
pip install rodrigo0000-fastapi-core-config
```

## Usage

```python
from rodrigo0000_fastapi_core_config import Settings

settings = Settings()
print(settings.DATABASE_URL)
print(settings.SECRET_KEY)
```

## Components

- **Settings**: Centralized configuration management
- **Security Config**: Security-related settings
- **Repository Utils**: Base utilities for repository pattern

## Requirements

- Python >= 3.8
- Pydantic >= 2.0.0
- Pydantic-settings >= 2.0.0

## License

MIT License

## Author

R Firm - Professional SaaS Development
rodrigo0000-fastapi-core-auth 1.0.2
Authentication module for FastAPI with JWT, OAuth2, and user management
License: MIT
Requires Python: >=3.8

# rodrigo0000-fastapi-core-auth

Authentication module for FastAPI with JWT, OAuth2, and user management.

## Features

- JWT token-based authentication
- OAuth2 password flow
- User registration and login
- Password hashing with bcrypt
- Token refresh functionality
- User management repository

## Installation

```bash
pip install rodrigo0000-fastapi-core-auth
```

## Usage

```python
from rodrigo0000_fastapi_core_auth import router, AuthRepository
from fastapi import FastAPI

app = FastAPI()
app.include_router(router, prefix="/api/v1/auth", tags=["auth"])
```

## Components

- **AuthRepository**: Database operations for user authentication
- **Schemas**: Pydantic models for requests and responses
  - `LoginRequest`
  - `RegisterRequest`
  - `UserResponse`
  - `AuthResponse`
- **Router**: FastAPI router with authentication endpoints

## Requirements

- Python >= 3.8
- FastAPI >= 0.104.0
- SQLAlchemy >= 2.0.0
- Pydantic >= 2.0.0
- python-jose[cryptography] >= 3.3.0
- passlib[bcrypt] >= 1.7.4

## License

MIT License

## Author

R Firm - Professional SaaS Development
PILSkinMC 1.0.2
PILSkinMC is a basic Minecraft player skin renderer for Python's PIL (Pillow) library.
License: MIT

# PILSkinMC

PILSkinMC is a basic Minecraft player skin renderer for Python's PIL (Pillow) library.

## Table of Contents

* [Install](#install)
* [How it works?](#how-it-works)
* [Positioning](#positioning)
* [Skin type (poses)](#skin-type-poses)
* [Scaling](#scaling)

## Install

To install from PyPi

```sh
# Linux/mac
python3 -m pip install PILSkinMC

# Windows
py -3 -m pip install PILSkinMC
```

## How it works?

The library uses an isometric grid view to render skins with added shading to give a simple yet effective 3D look. Once imported you can simply paste in a pre-loaded skin file as such.

```py
image = Image.new('RGBA', (400, 400))
skin = Image.open('skin.png').convert('RGBA')

paste_skin(image, skin, xy=(20, 20))
```

## Positioning

The xy coordinates will be at the top left of the rendered model, if you require help with more complicated positioning you can use the `skin_get_bbox()` function to get the bounding box of the full model.

## Skin type (poses)

By default the `paste_skin()` function will presume skins are of the wide 4px arm variant, this can be changed by parsing in a `pose` which can be one of 4:

* `PILSkinMC.poses.SLIM`
* `PILSkinMC.poses.WIDE`
* `PILSkinMC.poses.SLIM_GRUM`
* `PILSkinMC.poses.SLIM_GRUM`

*(yes I added custom poses for Grum/Dinnerbone variants)*

## Scaling

By default the `paste_skin()` function will render skins at a scale of `64`, this is the size of the theoretical isometric grid that the skin is being rendered off of. To change it simply parse a `scale` with any integer value.

**Note:** It is recommended to only use scales that are powers of 2 (4, 8, 16, 32, 64, 128, etc) as irregular values can sometimes cause gaps in the resulting image.

The scale option can also be used in the `skin_get_bbox()` function to get the bbox with the desired scaling.
feedzgerald 0.1.0
Curate your RSS feeds by filtering existing ones
License: MIT
Requires Python: <4.0,>=3.9

## Feedzgerald

Feedzgerald is an application used to curate RSS feeds and by filtering existing ones. For example, it can be used to expose an RSS feeds to a YouTube channel for specific topics, or by excluding topics.

At the time of this writing, this is my personal feedzgerald configuration file:

```toml
[core]
output_folder = "/feeds"

[feeds.kexp_full_concerts]
name = "KEXP - Full Performances"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UC3I2GFN_F8WudD_2jUZbojA"
website = "https://www.youtube.com/@kexp"
title_filter = "Full Performance"

[feeds.knights_of_last_call]
name = "Knights of Last Call"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UCIVOFu4geQx5KrTTQwtIyMg"
website = "https://www.youtube.com/@KnightsofLastCall"
negative_title_filter = "Torchbearer"

[feeds.roll_for_combat]
name = "Roll for Combat"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UCU4p5Dgq5G8cA2OMU1SLpXw"
website = "https://www.youtube.com/@RollForCombat"
negative_title_filter = "Jewel of the Indigo Isles"

[feeds.backseat]
name = "Backseat"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UC2ijB3_Fg2pIW1g6FeIiYKA"
website = "https://www.youtube.com/@backseat_fr"
title_filter = "BACKSEAT - S0"

[feeds.dm_lair]
name = "The DM Lair"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UCk9dtbM-wjpLk134r55OUbg"
website = "https://www.youtube.com/@theDMLair"
negative_url_filter = "youtube.com/shorts/"
negative_title_filter = "Q&A"

[feeds.tiny_desk_concerts]
name = "Tiny Desk Concerts"
url = "https://www.youtube.com/feeds/videos.xml?channel_id=UC4eYXhJI4-7wSWc8UNRwD4A"
website = "https://www.youtube.com/@nprmusic"
title_filter = "Tiny Desk Concert"
```


### Installation

You can run
```console
$ pip install feedzgerald
$ feedzgerald -c ./path/to/config.toml
```

Alternatively, you can use the provided docker image to run `feedzgerald` without installing any python dependencies:
```console
$ docker run -it --rm \
  --name=feedzgerald
  -v path/to/feedzgerald/config.toml:/app/config.toml
  -v path/to/output_folder/feedzgerald:/feeds
  brouberol/feedzgerald
  --config /app/config.toml
```
pyuptimerobot 24.0.1
Python API wrapper for Uptime Robot.
License: MIT
Requires Python: >=3.14.0
Keywords: homeassistant, update, version

# pyuptimerobot

[![codecov](https://codecov.io/gh/ludeeus/pyuptimerobot/branch/main/graph/badge.svg)](https://codecov.io/gh/ludeeus/pyuptimerobot)
[![PyPI](https://img.shields.io/pypi/v/pyuptimerobot)](https://pypi.org/project/pyuptimerobot)
![Actions](https://github.com/ludeeus/pyuptimerobot/workflows/Actions/badge.svg?branch=main)


_Python API wrapper for Uptime Robot_

## Installation

```bash
python3 -m pip install pyuptimerobot
```

Look at the file `example.py` for a usage example.

## Contribute

**All** contributions are welcome!

1. Fork the repository
2. Clone the repository locally and open the devcontainer or use GitHub codespaces
3. Do your changes
4. Lint the files with `scripts/lint`
5. Ensure all tests passes with `scripts/test`
6. Ensure 100% coverage with `scripts/coverage`
7. Commit your work, and push it to GitHub
8. Create a PR against the `main` branch
tuix-core 0.1.0
Core engine for the TUIX framework.
License: MIT
Requires Python: >=3.9
Keywords: terminal, ui, cli, layout, engine, tuix

# 🧱 TUIX Core 0.1.0

> ⚠️ **ATTENTION:**  
> This version of the library is an **MVP (Minimal Viable Project)** release.  
> Many of the implemented functions exist in the codebase but are **not yet actively used**.  
> This version serves as the foundation for upcoming releases.

---

## 🧩 Overview

**TUIX** is a modular terminal UI engine inspired by web technologies.  
It introduces a **DOM-like component system**, a **layout engine**, and a **buffer-based rendering pipeline** for building structured and styled terminal interfaces.

---

## 🚀 Installation

You can install this library using:

```bash
pip install tuix-core
```

---

# ⚡ Example Usage

Even though this MVP version is limited, here’s a small example showing what it can currently do:

```python
from tuix.core import TuixEngine as Tuix

# Initialize the main application engine
app = Tuix()

# Create a new component of type "choice"
app.components.create(object_type="choice", object_id="choice")

# Set component properties
app.components.set_property(object_id="choice", param="label", value="Test")

# Define a list of choices with actions
app.components.set_property(
    object_id="choice",
    param="choices",
    value=[
        [
            {"name": "Test", "action": "pass"},
            {"name": "Test", "action": "pass"}
        ]
    ]
)

# Align the component to the center using margin mode
app.layout.margin_mode(object_id="choice", param=["margin_top", "margin_left"], mode="centered")

# Render the layout to the terminal
app.render.draw()
```

🖥️ This renders a simple `choice` component in the terminal, centered both vertically and horizontally.

---

# ⚙️ Future Plans

Both the `LayouEngine` and `RenderEngine` will be rewritten in upcoming versions to create a far more powerful and flexible structure(🤫 won’t spoil the details yet).

---

# ☕ Support

If this project interests you or helps you in any way,
you can support its development by buying me a coffee ❤️

---

# 📜 License

MIT License © 2025 custosh

```text
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```