semvec/pypi-packages huggingface dataset:
zlxmcp2025 0.0.11
ZLX MCP Server
Requires Python: >=3.10

# ZLX-MCP-Server

```bash
{
  "mcpServers": {
    "wisecon-mcp": {
      "command": "uvx",
      "args": [
         "--from",
         "zlxmcp",
         "zlx-mcp-server"
      ]
    }
  }
}
```

> pandas MCP

```bash
{
  "mcpServers": {
    "wisecon-mcp": {
      "command": "uvx",
      "args": [
         "--from",
         "zlxmcp",
         "zlx-mcp-pandas"
      ]
    }
  }
}
```

> report MCP

```bash
{
  "mcpServers": {
    "wisecon-mcp": {
      "command": "uvx",
      "args": [
         "--from",
         "zlxmcp",
         "zlx-mcp-report"
      ]
    }
  }
}
```

 > image_ocr MCP

 ```bash
{
  "mcpServers": {
    "wisecon-mcp": {
      "command": "uvx",
      "args": [
         "--from",
         "zlxmcp",
         "zlx-mcp-image_ocr"
      ]
    }
  }
}
```
osShared 0.1.4
oasis version 2.0 shared python package
Requires Python: >=3.11

# osShared

이문서는 oasis v2에서 사용하는 shared package 원본 소스 입니다. 특이사항에 대하여 참고할 수 있도록 작성된 문서로 필요시 참고 바랍니다.

## 1. pypi publish and verify

<!-- - `walter` 개인 pypi.org 가입 > api token 발행 -->

- 정홍 부장님에게 osShared 관련 권한 요청
- 개발자들은 개인계정의 token 값을 발행

### 1.1 MAC

- token을 `.pypirc`에 명시

```toml
[distutils]
index-servers =
    pypi

[pypi]
username = __token__
password = pypi-your-token
```

- token을 `~/Library/Application Support/pypoetry/auth.toml` 생성

```toml
[http-basic]
[http-basic.pypi]
username = "__token__"
password = "pypi-your-token"
```

- build and publish

```bash
poetry publish --build
```

### 1.2 Windows

- 아래의 명령어로 token 등록

```bash
  poetry config pypi-token.pypi your_token_key
```

> [!IMPORTANT]
> 반드시 하기 2개 versioning and revisioning 수행 필요
>
> version : pyproject.toml > version
>
> revision : revision_history.md > make history describe

- verify published python package(osShared)
  - `https://pypi.org/manage/project/osshared/releases/`

## 2. 기타 특이사항
telegrams 0.0.5b5
ㅤ
Requires Python: ~=3.10
Keywords: bot, bots, telegram

<p align="center">
 📦 <a href="https://pypi.org/project/telegrams" style="text-decoration:none;">Telegrams</a>
</p>


```python

from Telegrams.modules import Telegraph

telegraph = Telegraph(domain="graph.org")
telegraph.create_account(short_name='1337')

response = telegraph.create_page('Hey', html_content='<p>Hello, world!</p>')

print(response['url'])

```
kenshi-translator-toolkit 0.2.1
Ferramenta para extração e reinserção de textos em arquivos .mod do Kenshi (Beta)
Requires Python: >=3.8

# Kenshi Translator Toolkit (Beta)

Esse código foi refatorado com base no algoritmo apresentado no mod [google colab MOD Translation Helper](https://www.nexusmods.com/kenshi/mods/1667) do usuário [kongyo11](https://next.nexusmods.com/profile/kongyo11)

[![PyPI version](https://img.shields.io/pypi/v/kenshi-translator-toolkit.svg)](https://pypi.org/project/kenshi-translator-toolkit/)
[![GitHub license](https://img.shields.io/github/license/AlexPrestes/kenshi-translator-toolkit)](https://github.com/AlexPrestes/kenshi-translator-toolkit/blob/main/LICENSE)
[![GitHub issues](https://img.shields.io/github/issues/AlexPrestes/kenshi-translator-toolkit)](https://github.com/AlexPrestes/kenshi-translator-toolkit/issues)

⚠️ **Versão beta inicial** - Ferramenta em desenvolvimento ativo ⚠️

## Links Importantes
- **Repositório GitHub**: https://github.com/AlexPrestes/kenshi-translator-toolkit
- **Documentação**: https://github.com/AlexPrestes/kenshi-translator-toolkit/blob/main/README.md
- **Reportar Bugs**: https://github.com/AlexPrestes/kenshi-translator-toolkit/issues

## Instalação
```bash
pip install kenshi-translator-toolkit
```

## Uso básico
```python
from kenshi_translator_toolkit import Decoder, Encoder

# Inicializa os componentes
decoder = Decoder()
encoder = Encoder()

# Lê o arquivo original (binário) e decodifica os dados
with open("/path/to/original.mod", "rb") as f:
    content = f.read()
    data = decoder.decoder_mod(content)

# Modifica os campos de tradução (exemplo)
for record in data.data:

    if record.name:
        record.trans_name = 'record.name'

    if record.description:
        record.trans_desc = 'record.description'

    for dialog in record.text:
        dialog.trans_text = 'dialog.text'

# Codifica os dados novamente para um buffer binário
buffer = encoder.encoder_mod(data)

# Salva o resultado em um novo arquivo
with open("/path/to/translated.mod", "wb") as f:
    f.write(buffer)
```
=======
# kenshi-translator-toolkit
Ferramenta para extração e reinserção de textos em arquivos .mod do Kenshi
CheckmateSample 0.5.0
A sample project with checkerboard functionality
Requires Python: >=3.10

# CheckmateSample

This Python module provides a function to generate a checkerboard pattern using NumPy. The function make_checkerboard creates a 2D NumPy array representing a checkerboard with customizable board size and square (and rectangle) sizes. Can be used for geospatial ML problems to try and combat autocorrelation. The functions can export two (testing/training) and three (testing/training/validation) checkerboard patterns


## Parameters 

board_size (tuple[int, int]): Size of the board in (rows, columns).

square_size (tuple[int, int]): Size of each square in (rows, columns).

separation_size (int): Size of separation distance in pixels between squares.

validation (bool): If True, use a ternary (0, 1, 2) pattern; if False, use a binary (0, 1) pattern

verbose flag: True / False 

an example of this is:

```
checkerboard_01 = make_checkerboard(board_size=(70,70), square_size=(10,10), separation_size=2)
```

xarray only:

dim_names (dict): Dictionary specifying the names of x and y dimensions
da (xr.DataArray): Input DataArray to apply the checkerboard pattern to

an example of this:


```
ds = xr.tutorial.load_dataset('air_temperature')

air_temp = ds.air.isel(time=0)

square_size = (7, 5)  # 7x5 pixel squares
checkerboard_temp_0 = make_checkerboard_xr(air_temp, square_size, separation_size=3, keep_pattern=0, validation=False)
```

## Dependencies

numpy and xarray

## Usage

# Create a NumPy checkerboard
checkerboard = make_checkerboard((10, 10), (2, 2))

# Create an xarray DataArray
da = xr.DataArray(np.random.rand(100, 100), dims=['lat', 'lon'])

# Apply checkerboard pattern to DataArray
result = make_checkerboard_xr(da, (10, 10), keep_pattern=1)
sebsync 1.0.13
Synchronize Standard Ebooks catalog with local EPUB collection.
Requires Python: >=3.10
Keywords: book, download, ebook, standard, sync, synchronization

# Sebsync

The `sebsync` script synchronizes the [Standard Ebooks](https://standardebooks.org/) catalog with
your local EPUB collection.

## How it works

The script reads the Standard Ebooks [OPDS feed](https://standardebooks.org/feeds) and
reconciles the ebooks in their catalog against the EPUBs in your local filesystem,
downloading new ones or updating existing ones as necessary.

If a new ebook is detected in the catalog, then it will be downloaded into your downloads
directory. If an updated version of a book is detected in the catalog that is already in your
local filesystem, then the updated version will be downloaded and stored in the existing local
file.

The script can also display and/or remove outdated and/or deprecated ebooks. A local ebook file
is “deprecated” if its identifier has been replaced by a new identifier in the Standard Ebooks
catalog. This occurs when a book is renamed or substantially revised. Its replacement will be
downloaded as a new ebook.

## Requirements

This script uses Standard Ebooks' OPDS feed to access metadata on all books their catalog. In
order to do so, you need to be a member of the Standard Ebooks
[Patrons Circle](https://standardebooks.org/donate#patrons-circle) (or have previously produced
an ebook for Standard Ebooks). If you're not already a Standard Ebooks patron, please consider
becoming one. It's a tremendously valuable project, deserving of your support.

## Installation

It is easy to install sebsync using [uv](https://docs.astral.sh/uv/) or [pipx](https://pipx.pypa.io/stable/):

```
uv tool install sebsync
```
or
```
pipx install sebsync
```

## Example usage

```
sebsync --email addr@example.com --books /home/user/MyBooks --downloads /home/user/MyBooks/Downloads
```

## Questions and answers

Q1. *Why use a separate downloads directory for new ebooks?*

A1. This is a feature for those who want to easily recognize new ebooks, and to manually
rename and/or categorize them within their library. If this feature is not useful for you,
simply set `--downloads` to be the same directory as `--books`.

Q2. *Does this script support Kindle books?*

A2. Not presently. A cursory analysis of the Standard Ebooks AZW3 structure suggests that there
currently isn't a reliable method to reconcile Kindle ebooks with the OPDS feed catalog. If
this feature is important to you, please let us know by voting for
[this issue](https://github.com/pbryan/sebsync/issues/2) in GitHub.
CINEWIZ 1.0
**Cinewiz** is an open-source Python package designed to streamline the development of **multimodal applications** powered by **LLMs**, **RAG (Retrieval-Augmented Generation)**, and **web crawling**. It’s built for workflows that require dynamic content generation and automation in creative environments.
Requires Python: >=3.7

## 🎬 Cinewiz - Theatre Movie RAG GEN-AI

**Version:** 1.0 Beta

**Status:** Under Development  

**Author:** #asytrick

**Website:** [github.com/cinewiz](https://github.com/ssmool/cinewiz)  

**Contact:** eusmool@gmail.com  

**Cinewiz** is an open-source Python package designed to streamline the development of **multimodal applications** powered by **LLMs**, **RAG (Retrieval-Augmented Generation)**, and **web crawling**. It’s built for workflows that require dynamic content generation and automation in creative environments.

Use Cinewiz to:
- Generate **images from keywords** and visual prompts  
- Compose contextual **text content** using online data  
- Insert **QR codes** into generated artwork  
- Manage persistent URI lists for input/output resources  
- Expand and **globalize prompts** across multiple languages  
- Integrate easily with generative pipelines and AI toolkits


## 📦 Installation

Install Cinewiz directly from PyPI:

pip install cinewiz

> Requirements:
>
> * Python 3.7+

pip install rembg Pillow
pip install qrcode Pillow
pip install selenium webdriver_manager
pip install transformers

## 🚀 Features

* 🎨 Generate **images from prompt keywords**
* 🧠 Integrate with **RAG pipelines** and context databases
* 🌍 Support for **text globalization** and multilingual prompts
* 🔍 Web crawling for content gathering and inspiration
* 🧾 Auto-generate **text compositions** with contextual relevance
* 🖼️ Embed **QR codes** directly into your creative artwork
* 🌐 Configure **URI lists** for persistent generative pipelines
* 💡 Trigger everything from a **single keyword command**


## 💡 Why Cinewiz?

**Cinewiz** is part of a larger creative and modular system called **e-Wally**, which aims to develop a modern **Unix-like environment** for studios, multimedia servers, and content production offices. Its initial version is known as **CineOS Barsotti – Unix Like @buskplay**.

## 🙌 Special Thanks

* 🐍 Thanks to the **Python language** for its power, simplicity, and vibrant community
* 🖼️ Shout-out to the **Pillow library** for enabling rich image manipulation
* 🤝 Ongoing support from the **open-source community** and developers worldwide

## 🔗 License

This project is licensed under the **CC0 1.0 Universal**. Feel free to use, adapt, and contribute!

> **Cinewiz** – Creative AI for Multimedia Content, Open Source and Built in Python.
aiida-hyperqueue 0.3.0
AiiDA plugin for the HyperQueue metascheduler
Requires Python: >=3.9

[![Build Status](https://github.com/aiidateam/aiida-hyperqueue/workflows/ci/badge.svg)](https://github.com/aiidateam/aiida-hyperqueue/actions)
[![Docs status](https://readthedocs.org/projects/aiida-hyperqueue/badge)](http://aiida-hyperqueue.readthedocs.io/)
[![PyPI version](https://badge.fury.io/py/aiida-hyperqueue.svg)](https://badge.fury.io/py/aiida-hyperqueue)

# AiiDA HyperQueue plugin

AiiDA plugin for the [HyperQueue](https://it4innovations.github.io/hyperqueue/stable/) metascheduler.

| ❗️ This package is still in the early stages of development and we will most likely break the API regularly in new 0.X versions. Be sure to pin the version when installing this package in scripts.|
|---|

## Features

Allows task farming on Slurm machines through the submission of AiiDA calculations to the [HyperQueue](https://github.com/It4innovations/hyperqueue) metascheduler.
See the [Documentation](http://aiida-hyperqueue.readthedocs.io/) for more information on how to install and use the plugin.

## For developers

To control the loglevel of command, since we use the `echo` module from aiida, the CLI loglever can be set through `logging.verdi_loglevel`.

## Acknowledgenement
If you use this plugin for your research, please cite the following work:

#### HyperQueue

* J. Beránek *et al.*, *HyperQueue: Efficient and ergonomic task graphs on HPC clusters*, SoftwareX **27**, 101814 (2024); DOI: [10.1016/j.softx.2024.101814](https://doi.org/10.1016/j.softx.2024.101814)

#### AiiDA

* S. P. Huber *et al.*, *AiiDA 1.0, a scalable computational infrastructure for automated reproducible workflows and data provenance*, Scientific Data **7**, 300 (2020); DOI: [10.1038/s41597-020-00638-4](https://doi.org/10.1038/s41597-020-00638-4)
* M. Uhrin *et al.*, *Workflows in AiiDA: Engineering a high-throughput, event-based engine for robust and modular computational workflows*, Computational Materials Science **187**, 110086 (2021); DOI: [10.1016/j.commatsci.2020.110086](https://doi.org/10.1016/j.commatsci.2020.110086)
cs-dateutils 20250724
A few conveniences to do with dates and times.
Keywords: date, time, datetime, python, python3

A few conveniences to do with dates and times.

*Latest release 20250724*:
* unixtime2datetime: default tz now UTC.
* Some doc updates.

There are some other PyPI modules providing richer date handling
than the stdlib `datetime` module.
This module mostly contains conveniences used in my other code;
you're welcome to it, but it does not pretend to be large or complete.

Short summary:
* `datetime2unixtime`: Convert a timezone aware `datetime` to a UNIX timestamp. *WARNING*: a naive datetime is assumed to be in UTC.
* `isodate`: Return a date in ISO8601 YYYY-MM-DD format, or YYYYMMDD if not `dashed`.
* `localdate2unixtime`: Convert a localtime `date` into a UNIX timestamp.
* `tzinfoHHMM`: tzinfo class based on +HHMM / -HHMM strings.
* `unixtime2datetime`: Convert a a UNIX timestamp to a `datetime` in the timezone `tz`. *Note*: the default timezone is UTC, not the local timezone.
* `UNIXTimeMixin`: A mixin for classes with a `.unixtime` attribute, a `float` storing a UNIX timestamp.

Module contents:
- <a name="datetime2unixtime"></a>`datetime2unixtime(dt)`: Convert a timezone aware `datetime` to a UNIX timestamp.
  *WARNING*: a naive datetime is assumed to be in UTC.
- <a name="isodate"></a>`isodate(when=None, dashed=True)`: Return a date in ISO8601 YYYY-MM-DD format, or YYYYMMDD if not `dashed`.

  Modern Pythons have a `datetime.isoformat` method, you should use that.
- <a name="localdate2unixtime"></a>`localdate2unixtime(d)`: Convert a localtime `date` into a UNIX timestamp.
- <a name="tzinfoHHMM"></a>`class tzinfoHHMM(datetime.tzinfo)`: tzinfo class based on +HHMM / -HHMM strings.
- <a name="unixtime2datetime"></a>`unixtime2datetime(unixtime, *, tz: datetime.tzinfo = datetime.timezone.utc)`: Convert a a UNIX timestamp to a `datetime` in the timezone `tz`.
  *Note*: the default timezone is UTC, not the local timezone.
- <a name="UNIXTimeMixin"></a>`class UNIXTimeMixin`: A mixin for classes with a `.unixtime` attribute,
  a `float` storing a UNIX timestamp.

*`UNIXTimeMixin.as_datetime(self, tz: datetime.tzinfo = datetime.timezone.utc)`*:
Return `self.unixtime` as a `datetime`
with the timezone `tz` (default `UTC`).

*`UNIXTimeMixin.datetime`*:
The `unixtime` as a UTC `datetime`.

# Release Log



*Release 20250724*:
* unixtime2datetime: default tz now UTC.
* Some doc updates.

*Release 20230210*:
* Drop Python 2 support.
* Make timezones mandatory where previously they were assumed.

*Release 20210306*:
Initial release, used by cs.sqltags.
pape-docs 0.3.0
A tool for flexibly managing templated docs of all kinds.
Requires Python: >=3.13

# Pape Docs

Pape Docs is a command-line interface (CLI) tool designed to simplify the creation and management of templated documentation. It provides a straightforward, opinionated system for generating various types of documents (e.g., ADRs, tasks, notes) from predefined templates, ensuring consistency and reducing overhead.

## Features

### Streamlined Document Creation

The core functionality is provided by the `new-doc` script, which allows users to quickly create new Markdown documents based on pre-defined templates.

**Usage:**

```sh
uvx pape-docs new
```

Or, with `pape-docs` installed via `uv` as a tool (see installation instructions below):

```sh
new-doc
```

**Options:**

- `--priority <PRIORITY>`: Optional priority number for the document (e.g., "0100", "????" for unknown).
- `--doc-type <DOC_TYPE>`: Optional document type (e.g., "ADR", "Task", "Notes", "Bug").

### Robust Interactivity (Planned)

The `new-doc` script is designed to support both interactive and non-interactive modes.

- **Interactive Mode (Default):**
    - Prompts for required arguments (like the document title) if not provided via command-line options.
    - Re-prompts for invalid non-empty responses, providing reasonable defaults for empty responses.
- **Non-Interactive Mode (Planned Option):**
    - Will execute without any interactive prompts.
    - Will throw an error if any required arguments (e.g., title) are missing.

### Flexible Docs Directory Location

The script intelligently locates the `pape-docs/` directory where new documents should be placed. The search order is:

1. An environment variable (`PAPE_DOCS_DIR`).
2. A `pyproject.toml` file in the current or parent directories, looking for `[tool.pape-docs]."docs-dir"`.
3. An existing `pape-docs/` directory in the current or parent directories.

If none is found, the script exits before the user wastes time entering other information

### Packaged Template

Pape Docs comes with one pre-defined `doc.md` template. It's bundled with the application and are not user-configurable. This design choice reinforces the opinionated nature of the tool, aiming to prescribe a simple and consistent documentation system.

## Installation

If you want to add `new-doc` (and `pape-docs`) to your `$PATH`, you can install this package as a `uv` tool.

```sh
uv tool install pape-docs
```

`uv` allows updating tools with `uv tool upgrade [tool-name]` or `uv tool upgrade --all`.

## Development

### Setup

1. Clone the repository.
2. Install dependencies using `uv` (or `pip`):

    ```sh
    uv pip install -e .
    uv pip install -e ".[dev]"
    ```

### Linting and Formatting

This project uses `ruff` for linting and formatting.

```sh
ruff check .
ruff format .
```

### Testing

Tests will be written using `pytest`.

```sh
pytest
```
micropython-ina228 0.1.0
TI INA228 library for MicroPython
Keywords: micropython, TI, Texas Instruments, INA228, current, voltage, power


# TI INA228 library for MicroPython

The INA228 is an 85V precise power monitor from Texas Instruments
More information can be found at https://www.ti.com/product/INA228

## Basic Usage

```python
from machine import Pin, I2C
import ina228

ina = ina228.INA228(
    I2C(0,sda=Pin(21), scl=Pin(22), freq=400000),
    shunt_resistance=0.015,
    max_current=10,
)

print(f'Bus Voltage: {ina.voltage:.3f} V')
print(f'Current: {ina.current:.3f} A')
print(f'Shunt Voltage: {ina.shunt_voltage/ 1000:.3f} mV')
print(f'Temperature: {ina.temperature:.3f} °C')
print(f'Power: {ina.power:.3f} W')
print(f'Energy: {ina.energy:.3f} J')
print(f'Charge: {ina.charge:.3f} C')
print(f'Manufacturer: {ina.manufacturer_id}')
print(f'Device: {ina.device_id}')
```

There's a lot more you can do and I tried to make it as user-friendly and complete as possible. Just read the datasheet and anything you want to do, you should be able to do it with this library. Most of the calculations are automatic so you can don't have to worry about converting values to fit in the fields.

For example, you may want to configure the adc. Familiarize yourself with this in the
datasheet and then run something similar to the following.
```python
ina.configure_adc(
    mode=ina228.ADCMode.CONT_VBUS_VSHUNT,
    vbusct=ina228.CONVERSION_TIME[540],
    vshct=ina228.CONVERSION_TIME[540],
    vtct=ina228.CONVERSION_TIME[50],
    avg=ina228.AVERAGING_COUNT[4]
)
```

Or if you want to set a temperature threshold of 50 °C
```python
    ina.temp_limit = 50.0
    print(f'Temperature limit configured for {ina.temp_limit}')
```

And then to restore the device to the default configuration
```python
ina.reset()
```