semvec/pypi-packages huggingface dataset:
kzip 0.1.0
A compact Python library for archiving and extracting ZIP files.
Requires Python: >=3.8

# kzip

![Zip Archiver Logo](https://img.shields.io/badge/kzip%20-v0.1.0-blue?style=for-the-badge&logo=python)  
[![PyPI version](https://badge.fury.io/py/kzip.svg)](https://badge.fury.io/py/kzip)  
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)  
[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)  

A compact and easy-to-use Python library for archiving files and directories into ZIP files, as well as extracting ZIP archives. Built with standard Python libraries—no external dependencies required! 🚀

## Features ✨
- **Archive Files & Directories**: Recursively zip files or entire folders with customizable compression.
- **Extract ZIPs**: Easily unpack archives to any directory.
- **Lightweight**: Uses only `zipfile` and `os` from the standard library.
- **Flexible Compression**: Supports various ZIP compression methods (e.g., DEFLATED, STORED).
- **Cross-Platform**: Works on Windows, macOS, and Linux.

## Installation 📦
#### Install via pip from PyPI:

```bash
pip install kzip
```

## Quick Start ⚡
### Archiving Files
#### Create an instance of archiver and use the archive method:
```Python
from kzip import archiver

zip = archiver()  # Default compression: ZIP_DEFLATED

# Archive a file and a directory
zip.archive('my_archive.zip', ['example.txt', 'my_folder/'])
```
### Extracting Archives
#### Use the extract method to unpack:
```Python
from kzip import archiver

zip = archiver()

# Extract to current directory
zip.extract('my_archive.zip')

# Or to a specific folder
zip.extract('my_archive.zip', extract_to='output/')
```

### Custom Compression
#### Specify compression during initialization:
```Python
import zipfile
from kzip import archiver

zip = archiver(compression=zipfile.ZIP_STORED)  # No compression
zip.archive('fast_archive.zip', ['large_file.bin'])
```
## API Reference 📖
### Class: archiver
- `__init__(self, compression: int = zipfile.ZIP_DEFLATED)`: Initializes with optional compression type.
- `archive(self, zip_path: str, paths: list[str]) -> None`: Archives files/directories to a ZIP.
- `extract(self, zip_path: str, extract_to: str = '.') -> None`: Extracts ZIP to a directory.

## Error Handling ⚠️
Wrap calls in `try-except` for robustness:
```Python
try:
    archiver.archive('archive.zip', ['nonexistent.txt'])
except FileNotFoundError as e:
    print(f"Error: {e}")
```
## License 📄
This project is licensed under the MIT License - see the LICENSE file for details.
aeeprotocol 8.0.0b2
Vector traceability with legal certification for AI embeddings
Requires Python: >=3.9

# AEE Protocol v8
## Vector Traceability for the AI Era

**Protect your embeddings. Prove your ownership. Maintain compliance.**

AEE (Attribution & Evidence for Embeddings) is an open-source protocol for invisible watermarking of vector embeddings, with blockchain certification for legal proof. Survives 20% noise, <1% FP rate (10k tests).

### Quick Start
```python
pip install aeeprotocol  # DÃ­a 2

from aeeprotocol import AEEv8
aee = AEEv8(user_id=35664619)  # Tu DNI soberano

embedding = np.random.randn(768) / np.linalg.norm(np.random.randn(768))
marked, proof = aee.inject(embedding)
detection = aee.detect(marked)
print(f"Detected: {detection['detected']}, Confidence: {detection['confidence']}")
tappay 0.5.2
TapPay Client Library for Python
Requires Python: >=3.8


# TapPay Python SDK

![CI](https://github.com/shihweilo/tappay-python/workflows/CI/badge.svg)
[![PyPI version](https://badge.fury.io/py/tappay.svg)](https://badge.fury.io/py/tappay)
[![Python Versions](https://img.shields.io/pypi/pyversions/tappay.svg)](https://pypi.org/project/tappay/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

> [!IMPORTANT]
> **Python 2 Support Dropped**: As of version 0.5.0, this library no longer supports Python 2.7. Please use Python 3.8 or newer.

This is the unofficial Python client library for TapPay's Backend API. To use it you'll need a TapPay account. Sign up at [tappaysdk.com](https://www.tappaysdk.com).

## Installation

Install using pip:

```bash
pip install tappay
```

## Usage

### Initialization

```python
import tappay

# Initialize the client
client = tappay.Client(
    is_sandbox=True, 
    partner_key="YOUR_PARTNER_KEY", 
    merchant_id="YOUR_MERCHANT_ID"
)
```

For production, you can set `TAPPAY_PARTNER_KEY` and `TAPPAY_MERCHANT_ID` environment variables and omit them in the constructor:

```python
client = tappay.Client(is_sandbox=False)
```

### Pay by Prime

```python
# Create cardholder data
card_holder = tappay.Models.CardHolderData(
    phone_number="0912345678",
    name="Wang Xiao Ming",
    email="test@example.com"
)

# Make payment
response = client.pay_by_prime(
    prime="prime_token_from_frontend",
    amount=100,
    details="Order #123",
    card_holder_data=card_holder
)
print(response)
```

### Pay by Token

```python
response = client.pay_by_token(
    card_key="card_key",
    card_token="card_token",
    amount=100,
    details="Subscription"
)
```

### Refunds

```python
response = client.refund(
    rec_trade_id="rec_trade_id",
    amount=100
)
```

For more API details, please refer to the [TapPay Backend API Documentation](https://docs.tappaysdk.com/tutorial/zh/back.html).

## Development

### Setup

```bash
git clone https://github.com/shihweilo/tappay-python.git
cd tappay-python
pip install -e ".[dev]"
```

### Testing

Run tests using pytest:

```bash
pytest
```

## Contributing

Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
gresecml 0.3.7
A small CLI security toolkit
Requires Python: <4,>=3.13

# GresecML
This command-line tool analyzes network traffic from either a `.pcap` file or a live capture, and makes predictions using a TensorFlow model. Results can be displayed in the console and/or written to an HTML/CSV file.

---

## ⚠️ Important
This tool was developed solely as part of an academic school project. It is intended for educational purposes only and should not be used in production environments or relied upon for professional applications.

Do not use this tool to scan network traffic unless you own it or have proper authorization.

---

## Features
- Analyze `.pcap` files or capture of live network traffic  
- Predict traffic sessions using a TensorFlow model  
- Export results to an HTML report  
- Filter sessions by probability thresholds  
- Support for **lazy loading** to save memory  
- Verbose mode for detailed console output  

---

## Workflow
The prediction pipeline follows these steps:
1. 	Capture – Collects packets from a  file or live network interface
2. 	Sessions – Groups packets into sessions
3. 	Prediction – Runs sessions through the TensorFlow model
4. 	Output – Displays results in console and/or export to HTML

---

## Installation
Install with pip:
```bash
pip install gresecml
```

---

## Usage
Run the CLI with:

```bash
gresecml [OPTIONS] COMMAND [ARGS]...
```

For help:
```bash
gresecml --help
```
---
### Examples with "gresecml tf predict":

- **Analyze a `.pcap` file with tensorflow and save results to HTML**  
    ```bash
    gresecml tf predict -i traffic.pcap -o results.html
    ```

- **Run live capture on default interface for 60 seconds**  
    ```bash
    gresecml tf predict
    ```

- **Run live capture on a specific interface with custom timeout**  
    ```bash
    gresecml tf predict -if eth0 -t 120
    ```

- **Enable verbose output and full HTML report**  
    ```bash
    gresecml tf predict -i traffic.pcap -o results.html -v -efo
    ```

- **Filter sessions with normal probability ≤ 70%**  
    ```bash
    gresecml tf predict -i traffic.pcap -pnm 70
    ```

- **Use lazy loading to save memory**  
    ```bash
    gresecml tf predict -i traffic.pcap -ll
    ```

### Notes
- If no `--input` is provided, the tool defaults to live capture.  
- Lazy loading is recommended for large `.pcap` files to reduce memory usage.  
- The HTML output provides a structured table of predictions for possible further investigation. The table is sorted by the prediction_normal column.

### Example Output
When running with `--verbose`, predictions will be printed in the console.  
If `--output` is specified, results will also be saved as an HTML file.

---
realtimex-docs-server 0.1.4.dev12
MCP server that exposes local documentation to agents
Requires Python: >=3.10
Keywords: automation, documentation, fastmcp, mcp

# realtimex-docs-server

A FastMCP-based MCP server that makes local documentation available to RealTimeX agents.

## Features
- Serve documentation from bundled workflow files by default, or from a custom directory via CLI/env override
- List every documentation file with a single call
- Read documents as UTF-8 text with optional `offset`/`limit` line slicing
- Transport over stdio for MCP clients

## Configuration
By default, the server loads the workflow docs bundled with the package. To override, set the documentation root via the `--docs-path` CLI option or the `REALTIMEX_DOCS_ROOT` environment variable (CLI flag takes precedence).

## Usage
```bash
uvx realtimex-docs-server --docs-path /path/to/docs
```

Once connected, agents can call the `list_documents` and `read_document` tools to explore the configured directory. `list_documents` returns the full file inventory, while `read_document` accepts `offset` and `limit` parameters to fetch a window of lines and returns plain UTF-8 content without added numbering.

## Development
```bash
# Install dependencies
uv sync

# Run style or test tooling as needed
uv run ruff check
uv run pytest
```
autofaq-api 0.0.17
Этот модуль умеет работать с 3-мя API AutoFaq: External API, CRUD API, QUERY API. Как синхронно так и асинхронно
Requires Python: >=3.10
Keywords: AutoFaq AutoFAQ autofaq kb

# Модуль работы с AutoFAQ API

## Общие сведения

Установка

```
pip install autofaq-api
```

Данный модуль умеет работать со всеми 3-мя API AutoFAD:

- External API
- CRUD API
- QUERY API

Методы для каждого из классов валидируются через модуль Pydantic. Каждый метод подробно расписан и задокументирован в docstring.
В модуле поддерживаются как синхронные запросы так и асинхронные, каждый синхронный метод начинается с *sync_*, а асинхронный с *sync_*:

```python
import asyncio
from autofaq_api import AutoFaqCrud

af_client = AutoFaqCrud('https://chat.autofaq.ai', 'user_token')
result = af_conn.sync_get_services()
print(result)

async def main():
    result = await af_conn.async_get_services()
    print(result)

asyncio.run(main())

...

import asyncio
from autofaq_api import AutoFaqExternal

af_client = AutoFaqExternal('https://chat.autofaq.ai', 'user_login', 'password', 'service_id')
result = af_conn.sync_channel_get_file(channel_id, file_id)
print(result)

async def main():
    result = await af_conn.async_channel_get_file(channel_id, file_id)
    print(result)

asyncio.run(main())

...

import asyncio
from autofaq_api import AutoFaqQuery

af_conn = AutoFaqQuery('https://chat.autofaq.ai')
result = af_conn.sync_kb_query(service_id, service_token, query)
print(result)

async def main():
    result = await af_conn.async_kb_query(service_id, service_token, query)
    print(result)

asyncio.run(main())

```
bookletssg 0.3.0
minimal ssg for blogs & articles
Requires Python: >=3.8

# booklet

a minimal & tiny ssg for blogs & articles.

### how to use

1. install it using `pip install bookletssg`
2. initialize a project with `booklet init`
3. write whatever you want in `articles/`
4. build your blog using `booklet build`
5. upload `dist/` to your web!

### licensed under [MIT license](LICENSE)
djangocms-time-wizard 2.5.1
Simple plugin with django-time-wizard relation

=====================
djangocms-time-wizard
=====================

Simple plugins with django-time-wizard integration.

Quick start
===========

1. Install using pip::

    pip install djangocms-time-wizard

1. Add to your `INSTALLED_APPS`::

    'time_wizard',
    'djangocms_time_wizard',

2. Include the time_wizard admin URLs in your project urls.py::

    path('admin/', include('time_wizard.urls')),

3. Run `python manage.py migrate` to create the time_wizard and
   djangocms_time_wizard models.

Configuration
=============

The TimeWizard(Inline)-Plugin has a wrapper for its child-plugins if they are
not shown on published pages. You can also disable this in your settings.py::

    DJANGOCMS_TIME_WIZARD_WRAPPER = False

The wrapper is a simple div with the class `time-wizard` and inline styling.
You can customize its appearance to whatever you want. **Note** that
child-plugins with `inline` styling may appear different because of the
additional wrapper around.

Showing/Hiding content in editing mode
======================================

If you want content managers to be able to show/hide inactive time-wizard
content, you can do this by adding the following::

    path("admin/", include("djangocms_time_wizard.urls")),  # urls.py

Link to the settings view, for example in your toolbar::

    self.my_menu.add_link_menu(
        "Time Wizard Admin Settings",
        url=reverse("djangocms-time-wizard-cookie-settings"),
    )

Requirements
============

- django-cms
- django-time-wizard

Tests
=====

Setup your test environment with `virtualenv` and install the requirements
with `pip install .`. Also install `tox` via pip and simply run `tox`.
agentx-dev 2.4
A lightweight LLM agent framework with standard and structured tool support use, prompt management, and support for OpenAI.
Requires Python: >=3.8


# 🧠 Bruce Agent

**AgentX** is a lightweight, extensible agentic framework for building custom LLM agents with structured tool use, prompt templates, and integration with OpenAI and Gemini models.

## 🚀 Features

- 🔁 Custom reasoning loop (`AgentRunner`)
- 🧩 Structured tool execution (Pydantic-based)
- 💬 Prompt templating and management
- 🔌 LLM-agnostic: supports **OpenAI function calling** and **Google Gemini**
- 🪄 Easy-to-use API for building agents

## 📦 Installation

published to PyPI:

```sh
pip install agentx-dev==2.3
```

## Example use

```python
from agentx_dev import AgentRunner, AgentType,ChatModel
from pydantic import BaseModel
from agentx_dev.Tools import StructuredTool,StandardTool
# Define a sample Stuctured tool
class MultiplyTool(BaseModel):
    a: int
    b: int

def multiply(a: int, b: int) -> int:
    return a * b

# Define a sample Standard tool
def Weather(weather:str):
    return f"{weather} is currently at 28 degree with a high of 32 and a low of 18 "

# Create chat model and agent
ReAct=AgentType.ReAct
chat_model = ChatModel.GPT(model="gpt-4", temperature=0.7)
tools = [StructuredTool(name="MultiplyTool",
                        description="useful when you need to add two numbers",
                        func=multiply,
                        args_schema=MultiplyTool
                        ),
         StandardTool(name="Weather",
                      description="when you need to check the weather of a location, input should be the str of the location",
                      func=Weather)]
# Create an AgentRunner instance
agent = AgentRunner(model=chat_model,Agent=ReAct, tools=tools)

# Initialize the agent with user input
response = agent.Initialize("What is 5 times 8?",ChatHistory=[{'role':"assistant",'content':'hello there how is it going'}])

# Print the result
print(response.content)


# output the Agent completion
agent.Initialize("i need the weather in Barrie")


```

``` bruce_framework/
 
├──agentx_dev/
│       ├── __init__.py
│       ├── agent/
│       │   ├── __init__.py
│       │   └── agent.py
│       ├── runner/
│       │   ├── __init__.py
│       │   └── agent_run.py
│       └── chatmodel.py
├── README.md
├── LICENSE
└── pyproject.toml

```

## 📚 Documentation (Coming Soon)
### More tutorials, tool examples, and structured prompting guides coming soon.

## 🧑‍💻 Author
#### Bruce-Arhin Shadrach
#### 📧 brucearhin098@gmail.com
#### 🌐 GitHub

📝 License
MIT License