semvec/pypi-packages huggingface dataset:
charz-rust 0.2.3
Blazingly fast speed-ups for charz
Requires Python: >=3.10

# Charz Rust

Blazingly fast speed-ups for `charz`

This addon module is used to improve performance of certain tasks in `charz`.
Uses `Rust` and `abi3`.

## Example

Substituting `charz.Screen` with a faster `charz_rust.RustScreen`

```python
from charz import Engine, ...
from charz_rust import RustScreen


class MyGame(Engine):
    screen = RustScreen()  # You can configure the screen,
                           # just like you would with `charz.Screen`
```

## Versioning

`linflex` uses [SemVer](https://semver.org/), according to [The Cargo Book](https://doc.rust-lang.org/cargo/reference/semver.html).

## License

MIT
bisslog-fastapi 0.0.1
Framework-agnostic adapter for Bisslog. Connects external interfaces to use cases while keeping domain logic isolated and pure.
Requires Python: >=3.8
Keywords: hexagonal, adapters, bisslog, fastapi

# bisslog-fastapi

![PyPI - Version](https://img.shields.io/pypi/v/bisslog-fastapi?style=flat-square&color=blue)
![Tests](https://img.shields.io/badge/tests-passing-success?style=flat-square&logo=github-actions)
![License](https://img.shields.io/pypi/l/bisslog-fastapi?style=flat-square)

**Framework-agnostic adapter for Bisslog.**
Connects external interfaces to use cases while keeping domain logic isolated and pure.

`bisslog-fastapi` is the **FastAPI adapter** for the Bisslog hexagonal architecture framework. It allows you to expose your core business logic (Use Cases) as HTTP/WebSocket endpoints automatically, preserving the Clean Architecture principles.

It acts as a bridge:
1.  **Read Metadata**: Scans your Bisslog services and triggers.
2.  **Adapt**: Maps HTTP requests (Path, Query, Body, Headers) to your Use Case input arguments.
3.  **Execute**: Runs your Use Case (Sync or Async).
4.  **Respond**: formats the result back to JSON.

## Installation

```bash
pip install bisslog-fastapi
```

## Usage

You can use `bisslog-fastapi` in two ways: as a **Runtime Runner** or as a **Code Generator (Builder)**.

### 1. Runtime Runner (Recommended for Dev)

Dynamically mounts your use cases at startup without generating extra code files.

```bash
bisslog_fastapi run [--metadata-file FILE] [--use-cases-folder-path DIR]
                    [--infra-path DIR] [--encoding ENC]
                    [--host HOST] [--port PORT] [--reload]
                    [--workers WORKERS] [--log-level LEVEL]
```

Example:
```bash
bisslog_fastapi run --metadata-file bisslog.metadata.json --port 8000 --reload
```

### 2. Builder Strategy (Production)

Generates a static `main.py` file with all routes hardcoded. This is useful for inspection or performance optimization.

```bash
bisslog_fastapi build [--metadata-file FILE] [--use-cases-folder-path DIR]
                      [--infra-path DIR] [--encoding ENC]
                      [--target-filename FILE]
```

Example:
```bash
bisslog_fastapi build --target-filename main.py
```

Then run the generated file normally with uvicorn:

```bash
uvicorn main:app --reload
```

## Features

-   **Automatic Routing**: Uses `TriggerHttp` metadata to register routes.
-   **Smart Mapping**:
    -   `path_query.*` → URL Path parameters.
    -   `body.*` → JSON Body fields.
    -   `params.*` → Query parameters.
    -   `headers.*` → HTTP Headers.
-   **Async Support**: Native support for asynchronous Use Cases.
-   **OpenAPI Integration**: Automatically generates Swagger UI for your domain logic with correct signatures.
-   **CORS**: Configurable per-trigger via metadata.


## License

This project is licensed under the MIT License.  
See the [LICENSE](LICENSE) file for details.
prompts-sdk 0.1.0
Generate client libraries from prompts.
Requires Python: >=3.10

# PromptSDK

PromptSDK is a CLI tool for generating client code with appropriate type signature from a folder containing prompts in Markdown format.

## Installation

```bash
uv add prompt-sdk

uv run prompt-sdk --help
```

## Explanation

Prompts are often written in Markdown and can get quite long. Writing them directly into your Python function has some disadvantages. It has no syntax highlighting and also bloats up the Python source file.

```py
def format_prompt(doc_texts: str, doc_types_definitions: str):
    return """# Input

The following documents have been uploaded:

{doc_texts}

# Your task

Classify each page in each document into zero or one of the following document types, based on their content:

{doc_types_definitions}
""".format(doc_texts=doc_texts, doc_types_definitions=doc_types_definitions)

agent.run(format_prompt(...))
```

A naive solution would be to write the system prompt in an external Markdown file and read it in the Python code.

```markdown
# Input

The following documents have been uploaded:

{doc_texts}

# Your task

Classify each page in each document into zero or one of the following document types, based on their content:

{doc_types_definitions}
```

```py
prompt_path = PROMPTS_DIR / "classifier.md"
prompt = prompt_path.read_text()

agent.run(prompt.format(...))
```

The problem is that you need to inspect the Markdown file to know which variables are used in the prompt.
PromptSDK solves this by generating client code from a `prompts` folder.

```bash
ls prompts
# info_extractor.md  classifier.md

uv run promptsdk --input prompts --output generated_sdk.py --name SDK
```

```python
from .generated_sdk import SDK

agent.run(SDK.classifier(...))
```

## Prompt Templates

PromptSDK uses [jinja](https://github.com/pallets/jinja) to read the templates.

```markdown
---
name: "classifier"
description: "The text here appears as a docstring in the generated Python code."
---
# Example

PromptSDK finds variables that are enclosed in two curly braces. 
The type of the generated function argument is a String.

{{ example }}
```

## Configuration

PromptSDK looks at `pyproject.toml` for configuration options.
When not given it looks at the CLI flags.

```toml
# pyproject.toml

[tool.prompt-sdk]
input_path = "templates"
output_path = "generated_sdk.py"
use_class = true
class_name = "SDK"
```
ossimg 2.0.0
Image preprocessing library with filters and templates
Requires Python: >=3.7

IMAGE PREPROCESSING LIBRARY 

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)

[Project Status : Still Under Development]

This Python library provides a simple, code-based interface for apply various image editing features and predefined templates to pictures.

## 📋 Table of Contents

- [Features](#features)
- [Installation](#installation)
- [Contributing](#contributing)

## FEATURES
The library currently include four primary image editing features and three prepared editing templates for quick application. 

Editing Features (Manual Use)
- [Feature 1]: ***Change Brightness***
- [Feature 2]: ***Adjust Saturation***
- [Feature 3]: ***Adjust Sharpness***
- [Feature 4]: ***Adjust Shadow***

Predefined Templates (Quick Use)
- |Template A|: `Golden Hour`
- |Template B|: `Gritty Contrast`
- |Template C|: `Pastel Matte`


## Installations

### Option 1: From GitHub (Recommended)
```bash
pip install git+https://github.com/wamos0922/OSFPLibrary.git
```
### Option 2: From Source (For Development)
1. Open your Command Prompt (CMD) and navigate to your preferred working directory

2. Clone the OSFPLibrary repository:

    git clone https://github.com/wamos0922/OSFPLibrary.git

3. Navigate into the OSFPLibrary directory:

    cd OSFPLibrary

4. Install the package:

    pip install -e .

5. Back to working directory:

    cd ..

6. Clone the OSFPDemo repository:

    git clone https://github.com/wamos0922/OSFPDemo.git

7. Navigate into the OSFPDemo folder:

    cd OSFPDemo

8. Run the demo.py file:

    python demo.py


### Requirements

- Python 3.7 or higher
- Pillow (PIL) 9.0.0 or higher

## 🧪 Testing

Run tests with pytest:
```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run all tests
pytest

# Run with coverage
pytest --cov=ossimg tests/
```


## Contributing

If you're interested in contributing to this project, please feel free to fork the repository and submit a pull request! See [CONTRIBUTING.md](docs/CONTRIBUTING.md) for more detail.
elevate3d 0.5.1
3D terrain and structure reconstruction from single RGB images
Requires Python: >=3.8

# Elevate3D

**Generate 3D models from satellite & aerial images using deep learning.**

---

## Disclaimer

**Elevate3D is an experimental, early-stage project.**  
It's not production-ready, and results may be inconsistent depending on the input. Expect rough outputs, strange artifacts, and occasional surprises.

---

## Features

- Automatic Building Segmentation (Mask R-CNN)
- Elevation Prediction from RGB (Pix2Pix)
- 3D Mesh Generation (Open3D)
- Tree Detection with DeepForest
- Pretrained Models - No training required
- End-to-End Pipeline - From image to interactive 3D output

---

## Installation

Install with pip:

```bash
pip install elevate3d
```

---

## Usage

### 1. Web Interface (Recommended)

Run the local web app:

```bash
elevate3d-run
```

This launches a local server where you can upload images and view results interactively in your browser.

### 2. Python API

You can also run the pipeline programmatically:

```python
from elevate3d.run_pipeline import run_pipeline

run_pipeline("path_to_your_image.jpg")
```

This processes the image and opens a viewer window showing the 3D model.

---

## Input Requirements

- Accepts **aerial or satellite RGB images** (`.jpg`, `.jpeg`, `.png`)
- Images should ideally be top-down and contain visible buildings or tree cover

---

## How It Works

- **Mask R-CNN** segments buildings
- **Pix2Pix** generates DSM from RGB
- **Tree detection** adds tree geometry
- **ResNet-50** roof type detection
- **Open3D** constructs the final mesh (as `.glb`)

---

## License

MIT License. See [`LICENSE`](LICENSE) for details.
SWIIFT 0.16.3
A numerical model to study wave-induced fracture of sea ice floes.
Requires Python: >=3.10

# SWIIFT
Surface Wave Impact on sea Ice---Fracture Toolkit

[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)

A numerical model to study wave-induced fracture of sea ice floes.

- [Installation](#installation)
- [Usage](#usage)
- [Development](#development)
- [Acknowledgements](#acknowledgements)

## Installation

Make sure your Python version is at least 3.11.
In a terminal, run 
```console
python -m venv .venv
source ./venv/bin/activate
python -m pip install --upgrade pip
python -m pip install git+ssh://git@github.com/sasip-climate/swiift.git#egg=swiift
```
to install the latest version of `SWIIFT` and its dependencies in a
dedicated environment.

Alternatively, a specific version can be installed by specifying it in the git URL,
```console
python -m pip install git+ssh://git@github.com/sasip-climate/swiift.git@$ver#egg=swiift
```
where `$var` is to be replaced by the desired version tag (for instance, `v0.4.0`).

> [!NOTE]
> Depending on your system, you might have to replace the command `python` with
> `python3`, or even a specific minor version such as `python3.11`.

## Usage

### Setting up an experiment

### Running an experiment

### Helper classes


## Development

### Using Hatch

This project is managed with [Hatch](https://github.com/pypa/hatch).
Refer to [its documentation](https://hatch.pypa.io/latest/install) for installation.

Once Hatch is installed, run
```console
git clone git@github.com:sasip-climate/swiift.git
cd swiift
hatch test --all --parallel
```
to install `SWIIFT` along with its dependencies, and run the test suite in
a dedicated environment.


## Acknowledgements

This work is part of the [SASIP project](https://sasip-climate.github.io/),
funded by Schmidt Sciences.
pyfastnoiselite 0.0.7
Cython wrapper for Auburns' FastNoise Lite.
Requires Python: >=3.6

[![Build Status](https://travis-ci.org/tizilogic/PyFastNoiseLite.svg?branch=master)](https://travis-ci.org/tizilogic/PyFastNoiseLite)

# Cython wrapper for the [FastNoise Lite](https://github.com/Auburn/FastNoise/) library

This wraps Auburns' great [FastNoise Lite](https://github.com/Auburn/FastNoise/)
library using Cython  for use in Python 3.6+

## Installation

This package is available on the [Python Package Index](https://pypi.org) both
as source and binary distribution for a variety of Python versions and
platforms using the following command:

```bash
pip install pyfastnoiselite  # On some systems, "pip" has to be replaced by "pip3"
```

> __Note__:
>
> This wrapper currently lacks the domain warping functionality and
> documentation. Both are planned to be added in the future.

## Usage

```py
from pyfastnoiselite.pyfastnoiselite import FastNoiseLite, NoiseType

# Initializing with seed
noise = FastNoiseLite(seed=1337)
# Set noise type (optional, defaults to OpenSimplex2)
noise.noise_type = NoiseType.NoiseType_OpenSimplex2S

# Get 2D noise
print(noise.get_noise(34, 22)) # 0.7130074501037598
print(noise.get_noise(100, 110)) # -0.614801287651062

# Get 3D noise
print(noise.get_noise(95, 100, 30)) # -0.45421651005744934


import numpy as np

Xs = [3, 57, 95]
Ys = [4, 13, 100]
Zs = [0, -4, 30]
coords = np.array([Xs, Ys, Zs], dtype=np.float32)
# Generate noise for each coordinate
print(noise.gen_from_coords(coords)) # [0.11303097 -0.5841235  -0.45224023]
```
trace-to-log 0.2.0
Add minimal tracing to a function using a decorator
Requires Python: >=3.8

# trace-to-log

A simple library to add some logging of selected functions via a `trace`
decorator.

By default, tracing is only enabled if `TRACE_ME` environment variable is set

Example:

```python
from trace_to_log import trace

@trace('*')
def adder(x:int, y:int) -> int:
    return x + y
```

Note, the '*' argument means all arguments should be logged. Otherwise, no
arguments are logged.

Now, calling `adder` will result in the following log entries at DEBUG level:

```
Going to call adder with args:
x :: 1
y :: 2
adder took 9.5367431640625e-07 seconds
Finished adder, returned:3
```

## being picky

If you don't want to log every argument, maybe because the string representation
of one of the objects is verbose, you can explicitly select which arguments
to log:

```python
from trace_to_log import trace

@trace('x')
def adder(x:int, y:int) -> int:
    return x + y
```

This will result in:

```
Going to call adder with args:
x :: 1
adder took 9.5367431640625e-07 seconds
Finished adder, returned:3
```

## custom argument conversions

Make log interpretation easier with a custom representation:

```python
from trace_to_log import trace

to_hex = lambda x: format(x, '#010x')

@trace('value', address=to_hex)
def write_32(address:int, value:int):
    pass
```

This will result in:

```
Going to call write_32 with args:
address :: 0x20000000
value :: 12"
write_32 took 1.6689300537109375e-06 seconds
Finished write_32, returned:None
```


## Unconditionally enabling tracing

```python
from trace_to_log import make_trace

trace = make_trace(
    trace_enable=lambda: True,
)

@trace('*')
def adder(x:int, y:int) -> int:
    return x + y
```
pyksolve 0.0.14
Cython wrapper for Klondike-Solver.
Requires Python: >=3.6

[![Documentation Status](https://readthedocs.org/projects/pyksolve/badge/?version=latest)](https://pyksolve.readthedocs.io/en/latest/?badge=latest)
[![Build Status](https://travis-ci.org/tcdude/py-klondike-solver.svg?branch=master)](https://travis-ci.org/tcdude/py-klondike-solver)

# Cython wrapper for [ShootMe/Klondike-Solver][ks]

Thin Python package to wrap the functionality of the [Klondike-Solver][ks] for
use in Python using Cython.

To get started, have a look at the [documentation][docs].


[ks]: https://github.com/ShootMe/Klondike-Solver
[docs]: https://pyksolve.readthedocs.io
EpicAuthAsync 1.0.0
An asynchronous Epic Games authentication library
Requires Python: >=3.12

# EpicAuth-Async

[![PyPI version](https://badge.fury.io/py/EpicAuthAsync.svg)](https://badge.fury.io/py/EpicAuthAsync)
[![Python versions](https://img.shields.io/pypi/pyversions/EpicAuthAsync.svg)](https://pypi.org/project/EpicAuthAsync/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**An asynchronous, lightweight Python library for interacting with Epic Games Store (EGS) and Epic Online Services (EOS) authentication endpoints.**

Originally built for personal use on a Discord Bot, this library has been open-sourced to help the community easily manage Epic Games sessions, OAuth tokens, and client data.
Thanks to Jaren for the Client API and LeleDerGrasshalmi for the documentation of all of this :)

---

## Features

-   **Fully Asynchronous:** Built on top of `aiohttp` for non-blocking performance.
-   **Client Management:** Automatically fetches and maps known Epic clients from `egs.jaren.wtf`.
-   **Comprehensive OAuth Support:** Handles multiple grant types including:
    -   `authorization_code`
    -   `client_credentials`
    -   `device_auth` / `device_code`
    -   `exchange_code`
    -   `password`
-   **Session Control:** Verify tokens, kill sessions, and inspect continuation tokens.
-   **Type Safe:** Includes full typing definitions and Pydantic models for responses (`TokenResponse`, `ExchangeCodeResponse`, etc.).

---

## Installation

Install directly from PyPI:

```bash
pip install EpicAuthAsync
```

## AI Prompt?

Checkout the AI Prompt [here](./AI_PROMPT.txt) :)