semvec/pypi-packages huggingface dataset:
rob-dl 0.1.3
rob is a tool that combines curl and yt-dlp to easily download YouTube videos and Files
Requires Python: >=3.14

# Yippee!
rob isn't a broken tool anymore!<br>
The previous versions of rob were hard to install, pretty garbage, and kind-of hard to use. Now, rob is distributed using pip. Alternativly, you can download binaries for your OS (.exe for windows, executable shell file for linux, etc) Actual README starts below:

# rob - command line downloader tool
<img alt="MIT License" src="https://img.shields.io/github/license/iddu0/rob.svg"/>
<img alt="Latest Github Release" src="https://img.shields.io/github/v/release/iddu0/rob.svg"/>
<img alt="Latest PyPI Release" src="https://img.shields.io/pypi/v/rob-dl.svg"/>
<img alt="Github Repo Size" src="https://img.shields.io/github/repo-size/iddu0/rob.svg"/>
<img alt="PyPI Build Status" src="https://img.shields.io/github/actions/workflow/status/iddu0/rob/python-publish.yml.svg?label=pypi%20build"/>
<img alt="Executable Build Status" src="https://img.shields.io/github/actions/workflow/status/iddu0/rob/executable-build.yml.svg?label=executable%20build"/>
dlglab 0.6.0
A simple package that prints hello world
Requires Python: >=3.6

# dlglab

A simple Python package that provides a basic print function.

## Installation

You can install `dlglab` via pip:

```bash
pip install dlglab
```

## Usage

```python
import dlglab

result = dlglab.print()
print(result)  # Output: Hello World
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
torch-fbm 0.1.0
Fractional Brownian motion and related processes in PyTorch

# torch-fbm

Fractional Brownian motion (fBm) and fractional Gaussian noise (fGn) generators, layers, and processes in PyTorch.

Features
- Fast Davies–Harte and exact Cholesky fGn generators: see `torch-fbm/generators.generate_davies_harte` and `torch-fbm/generators.generate_cholesky`.
- fBm paths via cumulative sum: `torch-fbm/generators.fbm`.
- Fractional OU and Geometric fBm processes: `torch-fbm/processes.fractional_ou_process`, `torch-fbm/processes.geometric_fbm`.
- Noisy linear layer and positional embeddings using fBm: `torch-fbm/layers.FBMNoisyLinear`, `torch-fbm/layers.FractionalPositionalEmbedding`.
- Hurst exponent estimator: `torch-fbm/estimators.estimate_hurst`.
- RL action noise stream: `torch-fbm/rl.FBMActionNoise`.

Install
- Editable install:
	- In VS Code terminal:
		- `pip install -e .`

Quick Usage
- Generate fBm (torch-only):
	- Python:
		- `import torch`
		- `from torch_fbm import fbm, get_default_device, set_seed`
		- `device = get_default_device(); set_seed(42)`
		- `path = fbm(n=1024, H=0.7, size=(4,), method='davies_harte', device=device, dtype=torch.float32)`
- Noisy Linear:
	- Python:
		- `from torch_fbm import FBMNoisyLinear`
		- `layer = FBMNoisyLinear(32, 10, H=0.5, method='davies_harte', device=device, dtype=torch.float32, seed=123)`
		- `x = torch.randn(8, 32, device=device)`
		- `layer.train(); y1 = layer(x); y2 = layer(x)`
		- `layer.eval(); y3 = layer(x)`
- Processes:
	- Python:
		- `from torch_fbm import geometric_fbm, fractional_ou_process`
		- `s = geometric_fbm(n=1000, H=0.7, mu=0.05, sigma=0.2, t_max=1.0, s0=100.0, device=device, dtype=torch.float32)`
		- `x = fractional_ou_process(n=2048, H=0.6, theta=0.2, mu=0.0, sigma=0.5, dt=1/256, device=device, dtype=torch.float32)`

Hurst Estimation
- `from torch_fbm import estimate_hurst`
- `H = estimate_hurst(path.unsqueeze(0), min_lag=4, max_lag=64, assume_path=True)`

RL Action Noise
- `from torch_fbm import FBMActionNoise`
- `noise = FBMActionNoise(mean=0.0, sigma=0.2, H=0.7, size=(1,), buffer_size=10000, method='davies_harte', device=device, return_torch=True, dtype=torch.float32, seed=7)`
- `a = noise()`

Notes
- Choose `method='davies_harte'` for speed ($O(N \log N)$), `cholesky` for validation ($O(N^3)$).
- `H` is clamped to $[0.01, 0.99]$ for stability.
- Set `dtype` and `seed` in generators for reproducibility.
- Torch-only: examples avoid `.numpy()` to work even if NumPy isn't available.
meshwell 2.2.0
GMSH wrapper, with integrated photonics focus
Requires Python: >=3.11
Keywords: python

# Meshwell
<p align="center">
  <img src=https://raw.githubusercontent.com/simbilod/meshwell/main/meshwell.png
 width="300" height="300">
</p>

---

[![Docs](https://github.com/simbilod/meshwell/actions/workflows/pages.yml/badge.svg)](https://github.com/simbilod/meshwell/actions/workflows/pages.yml)
[![Tests](https://github.com/simbilod/meshwell/actions/workflows/test_code.yml/badge.svg)](https://github.com/simbilod/meshwell/actions/workflows/test_code.yml)
[![PiPy](https://img.shields.io/pypi/v/meshwell)](https://pypi.org/project/meshwell/)

**Project is under active development, stay tuned for improved features, documentation, and releases!**

Meshwell is a Python wrapper around [GMSH](https://gmsh.info/) and [MMG](https://github.com/MmgTools/MMG) that streamlines the CAD definition, meshing, and remeshing of geometries parametrized by [Shapely](https://shapely.readthedocs.io/en/stable/) polygons (and more).
pytest-insubprocess 1.2
A pytest plugin to execute test cases in a subprocess
Requires Python: >=3.7
Keywords: pytest, subprocess, testing

# pytest-insubprocess

A pytest plugin for running tests in isolated subprocesses.

## Features

- Run pytest tests in separate subprocesses for better isolation
- Proper handling of test failures and exceptions across process boundaries
- Maintains pytest's output formatting and reporting
- Preserves pytest command-line options in subprocesses

## Installation

You can install `pytest-insubprocess` via pip:

```bash
pip install pytest-insubprocess
```

## Usage

Once installed, the plugin is automatically registered with pytest. To run your tests in subprocesses, use the `--insubprocess` flag:

```bash
pytest --insubprocess
```

### Basic Example

```python
# test_example.py
import os
import pytest

@pytest.mark.insubprocess
def test_isolated():
    print(f"Running in process: {os.getpid()}")
    assert True
```

Run with:
```bash
pytest test_example.py
```

Each test will run in its own subprocess, providing complete isolation.

## Why Use This Plugin?

- **Process Isolation**: Each test runs in a fresh subprocess, preventing side effects between tests
- **Resource Cleanup**: Processes are terminated after each test, ensuring clean state
- **Memory Isolation**: Memory leaks in one test won't affect others
- **System Resource Independence**: Tests that modify system state won't interfere with each other

## Requirements

- Python 3.7 or later
- pytest 7.0 or later

## Development

To contribute to pytest-insubprocess:

1. Clone the repository:
```bash
git clone https://github.com/pchanial/pytest-insubprocess.git
```

2. Create a virtual environment and install development dependencies:
```bash
python -m venv venv
source venv/bin/activate  # or `venv\Scripts\activate` on Windows
pip install -e ".[test]"
```

3. Run the tests:
```bash
pytest tests/
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## Links

- PyPI: [pytest-insubprocess](https://pypi.org/project/pytest-insubprocess)
- Source Code: [GitHub](https://github.com/pchanial/pytest-insubprocess)
- Issue Tracker: [GitHub Issues](https://github.com/pchanial/pytest-insubprocess/issues)

## Support

If you are having issues, please let us know by opening an issue on our [issue tracker](https://github.com/pchanial/pytest-insubprocess/issues).
ktml-agent 0.1.3
AI Terminal Agent
Requires Python: >=3.8

# kernel.sh
# AI Terminal

A natural language terminal assistant that translates your English requests into shell commands.

## Features

- **Natural Language to Shell**: Just type what you want to do.
- **Safety First**: Dangerous commands (like `rm -rf`) are flagged, and all commands require confirmation.
- **Context Aware**: Runs in your current shell session, preserving directory and environment.
- **Privacy**: Runs locally (logic) and uses your own API key.

## Installation

1. Run the installer:
   ```bash
   ./install.sh
   ```
2. Restart your terminal or source your config (e.g., `source ~/.zshrc`).

## Usage

1. Type `agent` to enter AI mode.
2. Type your request, for example:
   - "List all python files modified yesterday"
   - "Find the largest file in this directory"
   - "Undo the last git commit"
3. Review the suggested command.
4. Type `y` to execute, or anything else to cancel.
5. Type `exit` to leave AI mode.

## Configuration

The configuration file is located at `~/.config/ai_terminal/config`.
You can set your API key there:
```
GEMINI_API_KEY=your_key_here
```
Alternatively, you can export `GEMINI_API_KEY` in your environment.

## Requirements

- Python 3
- Bash or Zsh
- Gemini API Key