semvec/pypi-packages huggingface dataset:
greenstalk 2.1.1
A Python client for the beanstalkd work queue
Requires Python: >=3.8

Greenstalk
==========

.. image:: https://img.shields.io/pypi/v/greenstalk.svg
    :target: https://pypi.org/project/greenstalk/
    :alt: Greenstalk on PyPI

Greenstalk is a small and unopinionated Python client library for communicating
with the `beanstalkd`_ work queue. The API provided mostly maps one-to-one with
commands in the `protocol`_.

Quickstart
----------

.. code-block:: pycon

    >>> import greenstalk
    >>> client = greenstalk.Client(('127.0.0.1', 11300))
    >>> client.put('hello')
    1
    >>> job = client.reserve()
    >>> job.id
    1
    >>> job.body
    'hello'
    >>> client.delete(job)
    >>> client.close()

Documentation is available on `Read the Docs`_.

.. _`beanstalkd`: https://beanstalkd.github.io/
.. _`protocol`: https://raw.githubusercontent.com/beanstalkd/beanstalkd/master/doc/protocol.txt
.. _`Read the Docs`: https://greenstalk.readthedocs.io/
zippa 0.1.5
A Python utility for zipping directories and files
Requires Python: >=3.11

<h1 align="center">Automate dir zipping⚡️</h1>
CLI for flexibly zipping and extracting items.

## Features
* compress files and dirs as required
    - run command for zipping dirs/files of choice
    - run command for defining where compressed files should live

## Prerequisites
* Python 3.12+
* Git
* uv (recommended) or pip

## Quick Start

```bash
# Compress current directory
$ uv run zippa pack .

# Compress specific files
$ uv run zippa pack file1.txt dir1/ file2.py

# Extract zip file
$ uv run zippa extract backup.zip

# Extract to specific directory
$ uv run zippa extract backup.zip --output /path/to/extract/
```

## Common Patterns

### Working with Different Directories

```bash
# Compress from external directory
$ uv run zippa pack . --work-dir ~/path/to/project --output backup.zip

# Compress specific files from external directory
$ uv run zippa pack file1.txt dir1/ --work-dir ~/path/to/project
```

### Excluding Files

```bash
# Exclude patterns via command line
$ uv run zippa pack . --exclude "*.pyc" --exclude "__pycache__"

# Use .zipignore file (create in project root)
$ uv run zippa pack . --exclude-file .zipignore
```

### Overwrite Protection

```bash
# Default: Skip if files exist (safe)
$ uv run zippa pack . --output backup.zip

# Ask before overwriting (interactive)
$ uv run zippa pack . --output backup.zip --ask

# Force overwrite (non-interactive)
$ uv run zippa pack . --output backup.zip --force-overwrite
```

## .zipignore File

Create a `.zipignore` file in your project root:

```
# .zipignore example
*.pyc
__pycache__/
*.log
*.tmp
.git/
node_modules/
.env
*.DS_Store
build/
dist/
*.egg-info/
```

## Notes

- Items are relative to your current working directory (or `--work-dir` if specified)
- Output location can be anywhere (absolute or relative path)
- Use `--help` for complete command reference


## Future Updates
* [ ] make syntax for running commands more intuitive
* [ ] implement compression summary after each compression
* [ ] listen to events and compress correspondently
tano-gateway 0.2.0
Tano AI Security Gateway API
Requires Python: >=3.10

# Tano AI Security Gateway

FastAPI implementation of the Tano AI Security gateway service. The legacy Flask backend has been archived under `legacy-tano-ai-security-backend/`; all runtime traffic now flows through this gateway backed by Vertex AI Gemini.

## Local development

```bash
cd apps/gateway
uv venv .venv
source .venv/bin/activate
uv pip install -e .[dev]
uvicorn app.main:app --reload
```

Visit `http://localhost:8000/docs` for interactive documentation. Environment variables can be provided through an `.env` file; see `app/core/config.py` for the required keys.
wojtek-uk-postcodes 0.1.3
UK Postcodes validator package - under `wojtek` namespace
Requires Python: >=3.10

# wojtek-uk-postcodes

Small, typed utilities for working with UK postcodes. It ships with a strict parser that produces
a structured `UKPostcode` value object and companion helpers for validation and formatting.

## Features
- Parse raw strings into a frozen `UKPostcode` with outward/inward, area, district, sector, and unit parts.
- Validate standard postcodes and optional special cases such as BFPO, GIR, Overseas Territories, and Santa codes.
- Produce formatted strings with `FormatStyle` or JSON-ready dictionaries via `to_dict()`.
- Pure Python, zero external runtime dependencies, requires Python 3.10+.

### Validation scope and limitations
Validation checks only that inputs match UK postcode formats using regular-expression patterns (including known special-case rules).
It does not verify whether a postcode actually exists, is allocated, is currently valid, or is deliverable.

## Installation
Install the package from PyPI:

```bash
pip install wojtek-uk-postcodes
```

## Quick start
```python
from wojtek.uk_postcodes import FormatStyle, parse_postcode, is_valid_postcode

postcode = parse_postcode("SW1A 1AA")
print(postcode.outward)          # 'SW1A'
print(postcode.format())         # 'SW1A 1AA'
print(postcode.format(FormatStyle.NO_SPACES))  # 'SW1A1AA'

is_valid_postcode("GIR 0AA", allow_special=True)  # True
postcode.to_dict()
```

## Development
- Run the test suite: `uv run pytest` or `make test` (which also reports coverage).
- Type-check and lint: `make mypy` and `make format`.
pyising 0.1.3
Python bindings for the Ising2D C++ simulation
Requires Python: >=3.6

[![Upload Python Package](https://github.com/mmaleki92/pyising/actions/workflows/python-publish.yml/badge.svg)](https://github.com/mmaleki92/pyising/actions/workflows/python-publish.yml)

# PyIsing

PyIsing is a Python library for simulating the Ising model using C++ bindings via pybind11. It includes implementations of the Wolff and Metropolis Monte Carlo algorithms for efficient simulation of spin systems.

## Features
- Fast C++ core: Uses pybind11 to leverage high-performance C++ computations.
- Wolff Algorithm: Implements cluster updates for efficient decorrelation.
- Metropolis Algorithm: Standard single-spin update method.
- Flexible Parameters: Supports different lattice sizes, temperatures.

## installation
```bash
pip install pyising
```

for buliding from scratch

```bash
pythin setup.py install
```
## usage
```python
import pyising

temps = np.linspace(1, 4, 50)

L = 64
results = pyising.run_parallel_metropolis(temps, L, N_steps=N_steps,
                                          equ_N=equ_N,
                                          snapshot_interval=snapshot_interval,
                                          seed_base=seed_base,
                                          output_dir=output_dir,
                                          use_wolff=use_wolff,
                                          save_all_configs=save_all_configs
                                          )

```


# References
I built the code based on the following code, added the python binding and made it modular after refining the structure.
https://github.com/VictorSeven/IsingModel
nginx-defender 2.0.0
Web Application Firewall and threat detection for Python applications
Requires Python: >=3.8
Keywords: waf, security, firewall, threat-detection, nginx, protection

# nginx-defender Python Package

Python bindings for the nginx-defender Web Application Firewall and threat detection system.

## Installation

```bash
pip install nginx-defender
```

## Quick Start

```python
from nginx_defender import NginxDefender

# Initialize the defender
defender = NginxDefender()

# Start monitoring
defender.start()

# Check if an IP should be blocked
if defender.should_block("192.168.1.100"):
    print("IP should be blocked!")

# Monitor log files
defender.monitor_log_file("/var/log/nginx/access.log", "combined")
```

## Features

- Real-time threat detection
- IP blocking and monitoring
- Log file analysis
- Flask and Django middleware integration
- Configurable threat scoring
- Geolocation-based filtering

## Documentation

For full documentation, visit: https://github.com/Anipaleja/nginx-defender

## License

MIT License - see LICENSE file for details.
simplini 0.0.20
A simple INI file parser/writer
Requires Python: >=3.7
Keywords: ini, config, parser

![Simplini Logo](https://raw.githubusercontent.com/gubenkoved/simplini/main/resources/logo.png)

[![CI](https://github.com/gubenkoved/simplini/actions/workflows/ci.yml/badge.svg)](https://github.com/gubenkoved/simplini/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A **simple** INI file parser and writer for Python that works.

## Installation

```bash
pip install simplini
```

## Why?

The reasons this library was created:

* Standard library configparser does not support round trip editing (comments will not be written back), see https://docs.python.org/3/library/configparser.html
* Alternatives like https://github.com/DiffSK/configobj have a lot of bugs and are not actively maintained

## Comparison

| Library        | Round-trip editing | Maintenance  | Correctness | Configurability | Multi-line values | Error reporting  |
|----------------|--------------------|--------------|-------------|-----------------|-------------------|------------------|
| `configparser` | ❌                  | 🟢           | ✅       | ✅               | ✅                  | 🙂            |
| `ConfigObj`    | ✅                  | 🔴           | 🐛      | ❌               | ❌                  | 🤔                 |
| `python-ini`   | ❌                  | ❓           | ❓      | ✅               | ❓                | 🙁                 |
| `ini-parser`   |  ✅                 | ❓           | 🐛       | ❌                | ❌                 | 🙁               |
| `simplini`     | ✅                  | 🟢           | ✅        | ✅               | ✅                  | 🥰 |

## Features

* Simple API
* Round-trip editing preserving comments
* Non-ambiguous strings encoding
* Configurable parsing and rendering behavior
* No surprises like sudden interpolation or lower-casing option names

## Usage

Basic usage example:

```python
from simplini import IniConfig

# Create a new INI config
config = IniConfig()

# Add values to the default section
config.set("app_name", "My App")
config.set("version", "1.0.0")

# set values for some named section
config.set("db", "sql", section_name="core")

# Add a comment to the default section
config.unnamed_section.comment = [
    "Configuration for My App",
    "Created on 2025-09-28",
]

# Save to file
config.save("config.ini")

# Load from file
loaded_config = IniConfig.load("config.ini")
app_name = loaded_config.get("app_name")  # My App
core_db = loaded_config.get("db", section_name="core")  # sql
```

Example config file output:
```ini
# Configuration for My App
# Created on 2025-09-28

app_name = "My App"

version = "1.0.0"

[core]

db = "sql"

```

## License

MIT License