semvec/pypi-packages huggingface dataset:
knockssh 0.1.0
knockssh automates knock-and-ssh for a more convenient workflow
Requires Python: >=3.6

# knockssh

**knockssh** is a simple wrapper around [`ssh`](https://man.openbsd.org/ssh.1) and [`knock`](https://github.com/jvinet/knock), aimed at making the port-knocking workflow more convenient. 
It helps ensure your ports remain secure by reliably executing knock sequences before and after SSH sessions, so you'll never leave ports exposed by mistake.

## Installation
### Manual Installation from Source (Recommended)

The recommended approach is to install **knockssh** directly from source:

```bash
git clone https://git.andreasglashauser.com/git/knockssh.git
cd knockssh
pip install .
```
### Install from PyPI
**knockssh** is published on [PyPI](https://pypi.org/project/knockssh/).  

To install the latest release:
```bash
pip install knockssh
```
After installation, you can run:

```bash
knockssh --help
```

## Usage
Once installed, you can use `knockssh` to manage your SSH connections with integrated port-knocking.  
It uses a configuration file (default: `~/.knockssh.conf`) to store connection profiles, but you can override everything via command-line options.

### Command-Line Options
```
-s, --save             Save or update the specified profile in the config file and exit
-p, --profile NAME     Profile name to use or update (default: 'default')
-H, --host HOST        Override or set the host
-U, --user USER        Override or set the user name (default: 'user')
-P, --port PORT        Override or set the SSH port (default: 22)
-O, --open-ports PORTS Comma-separated ports to knock for opening
-C, --close-ports PORTS Comma-separated ports to knock for closing
-f, --config-file FILE Path to alternative config file (default: ~/.knockssh.conf)
-v, --verbose          Increase verbosity (use multiple times for more detail)
```

## Examples
### Basic SSH Connection with Port Knocking

If you have a profile already defined:

```bash
knockssh
```

This will:
- Load the default profile from the config file
- Execute the "open" knock sequence
- Initiate the SSH connection
- Execute the "close" knock sequence after the SSH session ends

### Using a Specific Profile
```bash
knockssh -p another_profile
```

Loads and uses the `another_profile` entry from the config.

### Direct Connection Parameters (No Profile)
```bash
knockssh -p myserver -H 1.2.3.4 -U user -O 7000,8000 -C 8000,7000
```

This will:
- Use `myserver` as the temporary profile name
- Connect to `1.2.3.4` with user `user`
- Knock ports 7000, 8000 to open
- SSH to the host
- Knock ports 8000, 7000 to close

### Saving a New Profile
```bash
knockssh --save -p new_profile --host myserver.com --ssh-port 2222 --user user --open-ports 1234,2345 --close-ports 2345,1234
```

This saves the given settings into the config file under `new_profile`. No SSH connection will be started.

### Updating an Existing Profile
```bash
knockssh --save -p another_server -H changed-host.com
```

This updates just the host of the `another_server` profile.

If you encounter any issues, have questions, or require further clarification, feel free to contact me. Happy knocking!
drapi-lemur 1.0.49
Data Request API for the Integrated Data Repository Research Services of University of Florida.
Keywords: CTSI, Clinical and Translational Science Institute, IDR, Integrated Data Repository, Integrated Data Repository Research Services, ODSRI, Office of Data Science and Research Implementation, Shands, Sloth 🦥, UF, UF Health, UFHealth, University of Florida

Data Request API for the Integrated Data Repository Research Services of University of Florida.
ThreadFactory 1.0.1
A high-performance thread-safe data structure and concurrency library for Python 3.13+ (no-GIL).
Requires Python: >=3.13
Keywords: concurrency, parallelism, thread-safe, no-GIL, threading, parallel processing, concurrent collections, multithreading, high-performance, python concurrency, free-threading, thread factory, ThreadFactory

# ThreadFactory

High-performance **thread-safe** (No-GIL–friendly) data structures and parallel operations for Python 3.13+.

> **NOTE**  
> ThreadFactory is designed and tested against Python 3.13+ in **No-GIL** mode.  
> It also works under the standard GIL runtime in Python 3.x, but you won't get the same concurrency benefits.
---

## 🚀 Features

### 1. ConcurrentBag  
- A thread-safe “multiset” collection that allows duplicates.  
- Methods like `add`, `remove`, `discard`, etc.  
- Ideal for collections where duplicate elements matter.

### 2. ConcurrentDict  
- A thread-safe dictionary.  
- Supports typical dict operations (`update`, `popitem`, etc.).  
- Provides `batch_update`, `map`, `filter`, and `reduce` for safe, bulk operations.

### 3. ConcurrentList  
- A thread-safe list supporting concurrent access and modification.  
- Slice assignment, in-place operators (`+=`, `*=`), and advanced operations (`map`, `filter`, `reduce`).

### 4. ConcurrentQueue  
- A thread-safe FIFO queue built atop `collections.deque`.  
- Supports `enqueue`, `dequeue`, `peek`, `batch_update`, `map`, `filter`, and `reduce`.  
- Raises `Empty` when `dequeue` or `peek` is called on an empty queue.

### 5. ConcurrentStack  
- A thread-safe LIFO stack.  
- Supports `push`, `pop`, `peek`, and common batch operations.  
- Ideal for last-in, first-out (LIFO) workloads.  
- Built on `deque` for fast appends and pops.

### 6. Parallel Utilities (TPL-like)  
- `parallel_for`, `parallel_foreach`, `parallel_invoke`, `parallel_map`.  
- Pure thread-based concurrency (No-GIL optimized), not tied to asyncio or multiprocessing.  
- Flexible chunking, concurrency control, local state usage, early exit on exception, and more.  
- Inspired by .NET's Task Parallel Library (TPL).

---

## ⚙️ Installation

### Option 1: Clone and Install Locally (Recommended for Development)

```bash
# Clone the repository
git clone https://github.com/yourusername/threadfactory.git
cd threadfactory

# Create a Python 3.13+ virtual environment (No-GIL/Free Threading recommended)
python -m venv .venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows

# Install the library in editable mode
pip install threadfactory
fastapi-autodoc 1.0.11
A FastAPI library for generating and managing project documentation
Requires Python: >=3.7

# FastAPI AutoDoc

FastAPI AutoDoc is a library designed to help developers generate and manage project documentation dynamically for Python projects. It integrates seamlessly with FastAPI and provides a web-based dashboard for managing and viewing documentation.

## Features

- **Dynamic Documentation**: Automatically generate documentation for Python FastApi projects.
- **Web-Based Dashboard**: View and manage documentation through a user-friendly interface.
- **File Watching**: Monitor project files for changes and update documentation in real-time.
- **REST API**: Expose endpoints for interacting with the documentation service programmatically.
- **Health Check**: Built-in health check endpoint to monitor the service.

---

## Installation

You can install the library using pip:

```bash
pip install fastapi-autodoc==1.0.10
```
---

## Usage

After installing the library, you can run the FastAPI AutoDoc server using the following command:

```bash
fastapi-autodoc generate
```

```bash
fastapi-autodoc runserver
```

This will start the server on `http://127.0.0.1:8000` by default.

---

## Accessing the Dashboard

Once the server is running, you can access the web-based dashboard at:

```plaintext
http://127.0.0.1:8000/api/v1/documentation/dashboard
```

From the dashboard, you can:
- View the list of documented projects.
- Generate new documentation.
- Monitor file changes in real-time.
- When you view the documentation, it will be displayed in a web-based interface. And you can always view detailed documentation

---

## Health Check

To verify that the server is running, you can access the health check endpoint:

```plaintext
http://127.0.0.1:8000/health
```

This will return a JSON response indicating the status of the service:
```json
{
  "status": "ok"
}
```

---

## Configuration

You can customize the behavior of FastAPI AutoDoc by setting environment variables in a `.env` file. For example:

```plaintext
PROJECT_PATH=the path to the project you want to document
DEBUG=True
```

---

## Contributing

Contributions are welcome! Feel free to open issues or submit pull requests on the [GitHub repository](https://github.com/BisiOlaYemi/fastapi-auto-doc).

---
h5xxhsum 0.1.0
Compute xxHash digest of hdf5 datasets
Requires Python: >=3.8

# hdf5-xxh
Compute a [xxHash](https://xxhash.com) of the Datasets in an [HDF5®](https://www.hdfgroup.org/solutions/hdf5/) file.

## Motivation

For regression testing, it is sometimes useful to check for the strict equality of numerical data stored in an HDF5 file.
A reference copy of the HDF5 file could be saved, but this is not always desirable, especially if the file is very large.
Computing a hash digest of the HDF5 file itself is not possible because, for various reasons, HDF5 files are not byte-for-byte identical, even if the stored data is the same.
This small utility computes a hash digest of the datasets stored in the HDF5 files, thereby enabling an easy check for strict equality without the need to store a complete copy of the data itself.

## Installation

The package is available on pypi:
```bash
pip install h5xxhsum
```

## Usage

```bash
$ h5xxhsum foo.h5
e92417e2e9a3425cffbe35fddc5f21a3  foo.h5
```

### Chunked storage

HDF5 supports [chunked storage](https://docs.h5py.org/en/stable/high/dataset.html#chunked-storage).
This utility implements a flag for controlling how the hash digest is computed:

- `--no-chunked`: the whole dataset is loaded in memory and hashed
- `--chunked`: the hash is computed incrementally, loading a chunk at a time, with the [`iter_chunks()`](https://docs.h5py.org/en/stable/high/dataset.html#h5py.Dataset.iter_chunks) method.

`--chunked` is faster, but the hash digest depends not only on the data itself but also on the chunk size/layout.
On the contrary `--no-chunked` is slower but idependent on the storage layout.

## Caveat emptor

I wrote this small utility for personal use, so there is no guarantee that the API will remain stable.
However, I believe it fills a small but useful niche.
Please feel free to open an issue if you think it can be improved.
vbumper 0.1.1
Comprehensive version bumping for Python projects
Requires Python: >=3.12

# vbumper

A comprehensive version management tool for Python projects.

It handles version bumping in a wide variety of formats, including pre-releases, development versions, and Git operations following PEP 440. It supports major.minor.patch versioning, with pre-release and post-release versions including dev, alpha, beta, rc, and post.

## Usage

```python
# Regular version bumping
vbumper                # 1.2.3    -> 1.2.4
vbumper minor          # 1.2.3    -> 1.3.0
vbumper major          # 1.2.3    -> 2.0.0

# Pre-release versions
vbumper dev            # 1.2.3    -> 1.2.4.dev0
vbumper alpha          # 1.2.3    -> 1.2.4a1
vbumper beta           # 1.2.4a1  -> 1.2.4b1
vbumper rc             # 1.2.4b1  -> 1.2.4rc1
vbumper patch          # 1.2.4rc1 -> 1.2.4

# Post-release version
vbumper post           # 1.2.4    -> 1.2.4.post1
```

All operations also include Git tagging and pushing changes to remote repository.
flareui 0.1.0
A modern Python UI Framework
Requires Python: >=3.8

# FlareUI

A modern Python UI framework for building reactive web applications with component-based architecture.

## Features

- 🔥 Component-based architecture
- ⚡ Virtual DOM implementation
- 🎨 Template syntax support
- 📦 Built-in state management
- 🔄 Lifecycle methods
- 🛣️ Built-in routing
- 🧩 Error boundaries
- 🔌 Plugin system

## Installation

```bash
pip install flareui
```

## Quick Start

```python
from flareui.core.component import Component

class Counter(Component):
    def __init__(self):
        super().__init__()
        self._state = {"count": 0}
    
    def template(self):
        return """
        <div>
            <h1>Count: {{ self._state['count'] }}</h1>
            <button @click="self.increment()">Increment</button>
        </div>
        """
    
    def increment(self):
        self.set_state({"count": self._state["count"] + 1})
```

## Documentation

For detailed documentation, visit our [documentation site](https://yourusername.github.io/flareui).

## Development

To set up the development environment:

```bash
git clone https://github.com/yourusername/flareui.git
cd flareui
pip install -e .[dev]
pytest
```

## License

MIT License

## Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request
myuiautomator 0.1
A simple library for Android UI automation using UIAutomator and ADB
Requires Python: >=3.6

# MyUIAutomator

حزمة `MyUIAutomator` هي مكتبة مبسطة للتحكم في واجهة أندرويد باستخدام `uiautomator`.

## 📌 المميزات
- التحكم في التطبيقات عبر ADB.
- تنفيذ الأوامر بسرعة باستخدام `uiautomator`.
- دعم للنقر، التمرير، وإدخال النصوص.

---

## 🔧 التثبيت
لتثبيت الحزمة، استخدم:
```bash
pip install myuiautomator
python-lockana 0.1.0
Python wrapper for the Lockana API
Requires Python: >=3.10.0

# Python Lockana

## О проекте
Python-Lockana это оболочка для **API [Lockana](https://github.com/NullPointerGang/Lockana)** которая предоставляет функциональность для аутентификации пользователей, управления секретами, администрирования пользователей и логирования. Этот проект реализует основные операции с API в Python и предоставляет удобный интерфейс для работы с Lockana.

## Примечания

1. Все операции, такие как создание пользователей или работа с секретами, требуют действующего токена, полученного через аутентификацию с TOTP.
2. Для выполнения запросов необходимо настроить сервер Lockana с правильным URL и портом.

## Функциональность

- **Аутентификация**:
  - Логин и логаут с использованием TOTP.
  
- **Работа с пользователями**:
  - Создание, удаление и получение списка пользователей.
  
- **Работа с секретами**:
  - Добавление, получение, обновление и удаление секретов.
  
- **Логирование**:
  - Получение и удаление логов.

## Установка

```bash
pip3 install python-lockana
```

### Требования

- Python 3.10+
- Библиотеки:
  - `requests`
  - `unittest.mock` (для тестов)


## Использование

### Пример использования клиента

```python
from lockana.client import LockanaClient

if __name__ == "__main__":
    # Инициализация клиента с логином и URL сервера
    client = LockanaClient("PYTHON_TEST", "http://localhost:8000")
    
    # Аутентификация пользователя с TOTP кодом
    client.auth_login(input("TOTP: "))
    
    # Добавление нового секрета
    client.secrets_add("TEST_SECRET", "TEST_SECRET_VALUE")
    
    # Получение списка секретов
    secrets = client.secrets_list()
    print(secrets)
    
    # Удаление секрета
    client.secrets_delete("TEST_SECRET")
    
    # Логаут пользователя
    client.auth_logout()
```

### Методы класса `LockanaClient`

- `auth_login(totp: str)`: Аутентификация пользователя с использованием TOTP.
- `auth_logout()`: Выход из системы.
- `secrets_add(secret_name: str, secret_value: str)`: Добавление нового секрета.
- `secrets_list()`: Получение списка всех секретов.
- `secrets_delete(secret_name: str)`: Удаление секрета.
- `create_user(username: str)`: Создание нового пользователя.
- `delete_user(username: str)`: Удаление пользователя.
- `list_users()`: Получение списка пользователей.


## Лицензия

Этот проект распространяется под лицензией MIT. Подробности можно найти в файле [LICENSE](LICENSE).
image-processing-malu 0.5.0
Pacote para processamento de imagens com histogram matching, similaridade estrutural e redimensionamento.
Requires Python: >=3.8

# image_processing_malu

## Funcionalidades

✔ **Histogram Matching** – Ajusta o histograma de uma imagem para corresponder ao de outra.  
✔ **Structural Similarity** – Mede a similaridade estrutural entre duas imagens.  
✔ **Resize Image** – Redimensiona uma imagem para um tamanho específico.  
✔ **Utils**:
   - Ler imagem (`read_image`)
   - Salvar imagem (`save_image`)
   - Exibir imagem (`plot_image`)
   - Exibir comparação de imagens (`plot_result`)
   - Exibir histograma de uma imagem (`plot_histogram`)

## Instalação

Use o gerenciador de pacotes [pip](https://pip.pypa.io/en/stable/) para instalar o `image_processing_malu`:

```bash
pip install image_processing_malu
```

## Uso
```bash
from image_processing_malu.processing import histogram_matching, structural_similarity, resize_image
from image_processing_malu.utils import read_image, save_image, plot_image, plot_result, plot_histogram
```

## Autor
Maria Luiza Romani
Código Fonte: Karina Kato