semvec/pypi-packages huggingface dataset:
ipa-fms 0.0.1
template python project with necessary configurations
Requires Python: >=3.10

# fastapi-starter

## features

1. pytest
2. pre-commit
3. darker for code format
4. ruff for lint
5. commitlint for commit message format
6. typer for cli

## 使用方式

- 初始化环境：
    `./scripts/setup`

- 执行测试：
    `uv run -m pytest`

- 运行cli：
    `uv run main.py --help`

- 运行服务：
    `uv run main.py serve`

- 构建发布：
    1. `cp .pypirc.example .pypirc`
    2. replace your token in `.pypirc`
    3. `git tag vx.y.z`
    4. `./scripts/publish`

- 构建可执行文件：
    `./scripts/build`
repology-client 0.6.0
Asynchronous wrapper for Repology API
Requires Python: >=3.12
Keywords: aiohttp, api, async, repology

<!-- SPDX-FileCopyrightText: 2023-2024 Anna <cyber@sysrq.in> -->
<!-- SPDX-License-Identifier: CC0-1.0 -->

repology-client
===============

[![Build Status](https://drone.tildegit.org/api/badges/CyberTaIlor/repology-client/status.svg)](https://drone.tildegit.org/CyberTaIlor/repology-client)
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8828/badge)](https://www.bestpractices.dev/projects/8828)

Asynchronous wrapper for [Repology API][repology-api].

> Note that API stability is currently not guaranteed - it may change at any
> moment.

[repology-api]: https://repology.org/api


Installing
----------

### Gentoo

```sh
eselect repository enable guru
emaint sync -r guru
emerge dev-python/repology-client
```

### Other systems

`pip install repology-client --user`


Packaging
---------

You can track new releases using an [RSS feed][rss] provided by PyPI.

[rss]: https://pypi.org/rss/project/repology-client/releases.xml


Contributing
------------

Patches and pull requests are welcome. Please use either [git-send-email(1)][1]
or [git-request-pull(1)][2], addressed to <cyber@sysrq.in>.

If you prefer GitHub-style workflow, use the [mirror repo][gh] to send pull
requests.

Your commit message should conform to the following standard:

```
file/changed: Concice and complete statement of the purpose

This is the body of the commit message.  The line above is the
summary.  The summary should be no more than 72 chars long.  The
body can be more freely formatted, but make it look nice.  Make
sure to reference any bug reports and other contributors.  Make
sure the correct authorship appears.
```

[1]: https://git-send-email.io/
[2]: https://git-scm.com/docs/git-request-pull
[gh]: http://github.com/cybertailor/repology-client


IRC
---

You can join the `#repology-client` channel either on [OFTC][oftc] or
[via Matrix][matrix].

[oftc]: https://www.oftc.net/
[matrix]: https://matrix.to/#/#repology-client:sysrq.in


License
-------

European Union Public License 1.2
django-gpg-keys-manager 0.1.0
Django reusable app to manage GPG public keys.
Requires Python: >=3.13
Keywords: django, gpg

# django-gpg-keys-manager

Reusable Django app to manage GPG public keys (export, verification, temporary keys fetched from keyservers).

## Quickstart

1. Create and activate a Python virtualenv

```bash
python -m venv .venv
source .venv/bin/activate
```

2. Install dependencies

```bash
pip install -r requirements.txt || pip install Django pgpy django-allauth
```

3. Run the example project (from repository root)

The repository includes helper tooling that integrates with the `uv` runner (used in this workspace).

Using `uv` (recommended in this workspace):

```bash
uv run manage.py migrate
uv run manage.py runserver
```

Or directly with Python:

```bash
python manage.py migrate
python manage.py runserver
```

The example project mounts the app at `/gpg/`.

## Notes
- The repository contains two app locations: the original `gpg/` and the new reusable package `gpg_keys/`.
- The module `gpg_keys.utils.get_request()` finds the active Django `HttpRequest` by walking stack frames; it's used where a global `request` variable used to be imported from `project.middleware`.

## Vercel deployment

This repository includes helper files for deploying to Vercel. Vercel will install dependencies from `requirements.txt` automatically. The build step compiles translations and collects static files.

Files added for Vercel:
- `requirements.txt` — Python dependencies
- `build.sh` — run `python manage.py compilemessages` and `python manage.py collectstatic --noinput`
- `vercel.json` — Vercel configuration (adjust if needed for your setup)

On Vercel the build will run `build.sh` and the Python server runtime will serve the Django app. You may need to set environment variables (e.g., `DJANGO_SECRET_KEY`, `DATABASE_URL`) in the Vercel project settings.
xsynth 0.3.0
A preprocessor for Python adding data modeling and structured programming
Requires Python: >=3.7
Keywords: preprocessor metaprogramming code-generation data-modeling

# XSynth

A preprocessor for Python that adds data modeling and structured programming features.

## Overview

XSynth transforms `.xpy` (XSynth Python) files into standard `.py` files, providing declarative data modeling and code generation capabilities without interfering with Python fundamentals.

## Features

- **Data Modeling**: Define data structures with `#$ dict` declarations
- **Structured Actions**: Generate classes and methods with `#$ action` declarations
- **Template Substitution**: Generate repetitive code patterns automatically
- **Synthesis Tracking**: SQLite database tracks modules, classes, and dependencies
- **Two Modes**: Stand-alone (minimal deps) or QuickDev integration (full features)

## Installation

```bash
pip install xsynth
```

Or install in development mode:

```bash
pip install -e ./xsynth
```

XSynth requires `qdbase` which will be installed automatically.

## Usage

### Command Line

Process all `.xpy` files in a directory:

```bash
xsynth
```

Process specific files:

```bash
xsynth file1.xpy file2.xpy
```

### Python API

```python
from qdutils.xsynth import XSynth

# Create XSynth instance
synth = XSynth(
    sources=['my_module.xpy'],
    verbose=True
)

# Process files
synth.run()
```

## XSynth File Format

XSynth files use the `.xpy` extension and contain special directives:

```python
#$ dict UserData
#$   name: str
#$   email: str
#$   created: datetime

#$ action CreateUser
#$   params: UserData
#$   returns: User
```

These directives are processed by XSynth to generate Python code with proper class definitions, type hints, and boilerplate.

## Modes

### Stand-alone Mode
- Minimal dependencies (only `qdbase`)
- Processes `.xpy` files in specified directories
- Suitable for any Python project

### QuickDev Mode
- Full integration with QuickDev framework
- Access to site configuration
- Enhanced code generation features

## Part of QuickDev

XSynth is part of the QuickDev metaprogramming toolkit. Other packages include:
- **qdbase** - Foundation utilities (required dependency)
- **qdflask** - Flask authentication with role-based access control
- **qdimages** - Flask image management with hierarchical storage

## License

MIT License - Copyright (C) Albert B. Margolis

## Requirements

- Python >= 3.7
- qdbase >= 0.2.0
qdbase 0.2.0
Foundation utilities for Python development with zero external dependencies
Requires Python: >=3.7
Keywords: utilities development tools dictionary sqlite cli lexer

# qdbase

Foundation utilities for Python development with zero external dependencies.

## Overview

`qdbase` is the foundation layer of the QuickDev metaprogramming toolkit, providing a collection of utilities for common development tasks. It has **zero external dependencies** beyond the Python standard library, making it lightweight and easy to integrate into any project.

## Key Modules

### exenv - Execution Environment
Detection and normalization of execution environments:
- Path manipulation with safety checks
- Directory and file utilities
- Environment detection

### pdict - Enhanced Dictionary
Extended dictionary functionality with additional utilities for data manipulation.

### qdsqlite - SQLite Helpers
Simplified SQLite database operations:
- Connection management
- Query helpers
- Schema utilities

### CLI Utilities
- `cliargs` - Command-line argument parsing
- `cliinput` - Interactive command-line input handling

### simplelex - Lexical Analysis
Simple lexical analysis utilities for parsing text and code.

### xsource - Source Processing
Source file processing classes used by the XSynth preprocessor.

## Installation

```bash
pip install qdbase
```

Or install in development mode:

```bash
pip install -e ./qdbase
```

## Usage

```python
from qdbase import pdict, qdsqlite, exenv

# Enhanced dictionary operations
data = pdict.PDict()

# SQLite helpers
db = qdsqlite.QdSqlite("mydb.db")

# Environment utilities
safe_path = exenv.safe_join("/base/path", "subdir")
```

## Part of QuickDev

`qdbase` is part of the QuickDev metaprogramming toolkit. Other packages include:
- **xsynth** - Preprocessor for generating Python from high-level declarations
- **qdflask** - Flask authentication with role-based access control
- **qdimages** - Flask image management with hierarchical storage

## License

MIT License - Copyright (C) Albert B. Margolis

## Requirements

- Python >= 3.7
- No external dependencies (stdlib only)
bota-payload-utils 0.0.2
Python binding for the Bota Payload Utils C++ library
Requires Python: >=3.8

# Bota Payload Utils Python bindings

Python binding for the Bota Payload Utils C++ library.

For more information about the Bota Payload Utils Python API, please refer to the [Bota Payload Utils documentation](https://code.botasys.com/en/gen_a/layer1/payload_utils/payload_utils_py.html).

For an usage example, please refer to the following repository: [bota_demo_py](https://gitlab.com/botasys/control_toolkit/bota_demo_py).

For a general start guideline with Bota Systems Force Torque sensors, please refer to the [Bota Systems startpage](https://shop.botasys.com/start).
PlayBaghChal 3.0.0
A Pygame implementation of the Bagh-Chal (Tiger and Goat) board game.
Requires Python: >=3.6
Keywords: pygame baghchal tiger goat board game

 # Bagh Chal

Bagh-Chal (Nepali: बाघ चाल), also known as the Tiger Game or Tiger and Goat Game, is a traditional strategy game from Nepal. This will guide you through the game’s rules, setup, and objectives.

## Requirements

- Python > 3.9
- Pygame

## Objective

- **Tigers:** Capture the goats.
- **Goats:** Prevent the tigers from capturing all of them and trap the tigers so they cannot move.

## Board

The board is a 5x5 grid with additional diagonal lines connecting the corners, creating a star-like pattern. The intersections of these lines are the points where pieces can be placed.

## Pieces

- **Tigers:** 4 pieces
- **Goats:** 20 pieces

## Setup

1. **Tigers:** Start on the board in specific locations (typically at the four corners of the board).
2. **Goats:** Start off the board and are introduced into the game one at a time.

## Installation

You can install the game using pip:

```sh
pip install PlayBaghChal
```

## Usage

Run the game using:
```py
from playbaghchal.PlayGame import TigerGame

# Create an instance of the game and run it
game = TigerGame()
game.run()
```
OR, Using Command line


```sh
python -m playbaghchal
```

## Gameplay

### Tigers' Turn

- Tigers can move to any adjacent intersection along the lines (vertically, horizontally, or diagonally).
- Tigers capture goats by jumping over them to an empty spot directly on the other side (similar to a checkers capture).

### Goats' Turn

- Goats are placed on empty intersections, one at a time, until all 20 goats are on the board.
- After all goats are on the board, they can move to an adjacent intersection along the lines.


## Controls

- **Tigers and Goats movement**: Click on a piece and then on a valid position to move.

## Winning the Game

- **Tigers Win:** By capturing 6 goats so that it is impossible to block all tigers.
- **Goats Win:** By trapping all the tigers so they cannot make any legal moves.

## Strategy

- **For Tigers:** Focus on capturing goats efficiently and blocking their movement.
- **For Goats:** Aim to create a formation that limits the movement of tigers and avoid being captured.

## Additional Notes

- The game requires careful planning and strategic thinking from both players.
- The placement of goats can significantly influence the tigers' ability to capture or move.


## License

This project is licensed under the MIT License.

## Contributing

Pull requests are welcome! If you'd like to contribute, feel free to fork the repo and submit a PR.

## Author

Developed by **Bhishan Pangeni**. 🚀
Enjoy your game of Bagh Chal!