semvec/pypi-packages huggingface dataset:
apitests 0.0.2
APITESTS: AI-Powered Runtime Test Generator for Microservices
Requires Python: >=3.8

# APITESTS: AI-Powered Runtime Test Generator for Microservices

Define `GenTestCase` blueprints with parameter sets; the framework generates a test for each combination, reducing boilerplate and increasing coverage.

## Installation
```bash
$ pip install apitests
```

## Key concepts

### AI-Powered Generation

Use a Large Language Model (e.g., Gemini) with a RAG system to auto-generate test parameters. The RAG fetches context from internal docs (API specs), and the LLM creates a dictionary of valid, invalid, and edge-case inputs for your `GenTestCase`.

### Black-Box Mocking

For black-box testing, `patch` your app's HTTP client to redirect traffic to a local **Active Stub Server**. The stub server queries the `GenTests` generator for dynamic, context-aware responses for each test, allowing you to test an unmodified application.

### Data Collection During Generation and "live documentation"
As tests are generated and run, the framework can collect valuable data, such as:
-   Request/response payloads from mocked services.
-   Application logs emitted during the test.
-   Performance metrics like response times.

This data can be aggregated into a report, offering insights into the application's behavior under different scenarios and aiding in debugging. This collected data can then be fed into a corporate RAG system, creating a form of "live documentation" that reflects the application's actual, tested behavior.

## Running the Generator

You can tag your `GenTestCase` tests and run them selectively with your test runner.

This will start test generation:

**Django:**
```bash
$ ./manage.py test animals --tag=generator
```

**Pytest:**
```bash
$ pytest tests/test_mod.py -m=generator
```


## PYPI publising:
1. Fix version 

2. Build

```bash
$ python -m build
```

3. Upload to pypi
```bash
$ python -m twine upload dist/*
```
latex-ocr-server 0.2.0
Turn image files into LaTeX equations with protocol buffers
Requires Python: >=3.7

# Latex OCR Server
![GitHub Release](https://img.shields.io/github/v/release/lucasvanmol/latex-ocr-server) ![PyPI - Version](https://img.shields.io/pypi/v/latex-ocr-server)


A protobuf-based service to generate latex equations from image files.

See the [`.proto` file](https://github.com/lucasvanmol/latex-ocr-server/blob/0.1.0/src/latex_ocr_server/protos/latex_ocr.proto) for the interface.

## Installation

```
pipx install latex-ocr-server
```

## Usage

```
usage: python -m latex_ocr_server start [-h] [--port PORT] [-d] [--cache_dir CACHE_DIR] [--cpu]

optional arguments:
  -h, --help            show this help message and exit
  --port PORT
  -d, --download        download model if needed without asking for confirmation
  --cache_dir CACHE_DIR
                        path to model cache. Defaults to ~/.cache/huggingface
  --cpu                 use cpu, otherwise uses gpu if available
```

## GPU support

`pytorch` must be installed with CUDA support. See https://pytorch.org/get-started/locally/.

You can check if gpu support is working with 
```
latex_ocr_server info --gpu-available
```

## Docker

```
docker build -t latex-ocr-server .    
```

Add a volume if you want to cache the model outside docker:

```
docker run  -p 50051:50051 -v /c/path/to/model_cache:/app/model_cache latex-ocr-server
```


# Development 

Development is done using `hatch`. Use `hatch shell` to setup your environment.

## Build

```
hatch build
```

## Locall Install

```
pip install ./dist/latex_ocr_server-0.1.0.tar.gz
```
django-matomo-api-tracking 0.2.0
Django app to track webtraffic serverside with Matomo API
Requires Python: <3.13,>=3.10

# Django Matomo API Tracking

This django app enables server side traffic tracking. The code is greatly inspired by the [Django Google Analytics](https://github.com/praekeltfoundation/django-google-analytics) app.

## Installation

1. Install ``django-matomo-api-tracking`` from pypi using ``pip install django-matomo-api-tracking``

## Setup / Configuration

1. add ``matomo_api_tracking`` to your ``INSTALLED_APPS`` setting.
2. add a new variable ``MATOMO_API_TRACKING`` to your settings to configure the behaviour of the app:


    MATOMO_API_TRACKING = {
        'url': 'https://your-matomo-server.com/matomo.php',
        'site_id': <your_site_id>,
        # 'ignore_paths': ["/debug/", "/health/"],
        # 'token_auth': "<your auth token>",  # e.g.  "33dc3f2536d3025974cccb4b4d2d98f4"
        # 'timeout': 8,
    }

3. enable the middleware by adding the matomo_api_tracking middleware to the list of enabled middlewares in the settings: 


    MIDDLEWARE = [
        ...
        'matomo_api_tracking.middleware.MatomoApiTrackingMiddleware',
    ]

In the settings part, the `ignore_path` can be used to entirely skip certain
paths from being tracked. If you specify an `token_auth`, the app will also send
the client's IP address (cip parameter). But this is not required. Additionally,
you can specify a timeout for the requests for middleware sent tracking data.
pygwin2 2.0.1
A library for creating GUI-applications on pygame.
Requires Python: >=3.7
Keywords: gui, pygame, windows

# Pygwin2

A library for creating GUI-applications on pygame.

[Documentation](https://github.com/MeexReay/pygwin2/blob/main/docs/DOCS.md)

## Usage

Here is a small example of usage (pygame style):

```py
import pygwin2 as pgw

win = pgw.create('Title',(500,500))

run = True
while run:
    for event in pgw.getEvents():
        if event.type == pgw.QUIT:
            run = False

    win.update()
pgw.close()
```

## Installation

The easiest way is to just use pip:

```sh
pip install pygwin2
```
django-react-cli 1.0.0
A starter template for building full-stack web applications using Django (backend), React (frontend), and TailwindCSS. Comes pre-configured with REST API support, authentication, and ready-to-use development and production settings.
Requires Python: >=3.7

Full-Stack Django + React + TailwindCSS ⚡

A one-command starter for a full-stack app with Django (backend) and React + TailwindCSS + Vite (frontend) — all in a single repo. Auto-configures for development and production.

## Windows:
- py -m pip install django-react-cli
- py -m django-react-cli

## Linux
python3 -m pip install django-react-cli
python3 -m django-react-cli


## 📦 Features

### Frontend

- ⚡ **Vite + React + TailwindCSS**
- 🛠️ Auto-generated `vite.config.js` and `index.css`
- 🌐 Env-based settings via `config.json`
- 🎨 Preconfigured fonts and theme

### Backend

- 🐍 **Django + Django REST Framework**
- 🔐 Token-based authentication
- 🌍 CORS support via `django-cors-headers`
- 📦 Whitenoise for static file handling
- 🗄️ SQLite (development) / PostgreSQL (production)
- 🌐 Env-based settings via `config.json`

### Extras

- 📁 Unified directory structure for frontend and backend
- ⚙️ Auto-generated `config.json` for easy environment switching
- 🚀 Django templates serve Vite dev server in development and built static files in production

---

## 🛠 Requirements

- **Python 3.8+**  
- **Node.js 18+ & npm**  
- **pip** (comes with Python)  
- **PostgreSQL** (only needed in production)

---

## Project Structure

```bash

your-project/
│── account/          # Django app
│── core/             # Django project
│── src/              # React source
│── static/           # Collected static files
│── dist/             # React build (prod)
│── env/              # Python virtualenv
│── media/            # Uploaded files
│── template/         # Django templates
│── config.json
│── requirements.txt
│── vite.config.js
│── manage.py
│── package.json
│── index.css

```

##  License
 django-react-cli is licensed under the MIT License.

## Contacto

[LinkedIn](https://www.linkedin.com/in/hugo345?utm_source=share&utm_campaign=share_via&utm_content=profile&utm_medium=android_app) hugo aragon