semvec/pypi-packages huggingface dataset:
ps2mqtt 0.0.8
Python daemon that gets information from psutil to an mqtt broker for integration with Home Assistant.

[![PyPI version](https://badge.fury.io/py/ps2mqtt.svg)](https://badge.fury.io/py/ps2mqtt)

# ps2mqtt
Python daemon that gets information from [psutil](https://github.com/giampaolo/psutil) to an mqtt broker for integration with [Home Assistant](https://www.home-assistant.io).

## Install

You can install ps2mqtt from pypi:
```bash
$ pip install ps2mqtt
```

If you wish to run ps2mqtt through systemd, download the ps2mqtt.service file from this repository and edit according to your system.

Then just copy to systemd path and enable the service before starting:

```bash

$ sudo cp ps2mqtt.service /etc/systemd/system/

$ sudo systemctl enable ps2mqtt.service 

$ systemctl start ps2mqtt.service 

```

## Options

ps2mqtt has several command line options you should use when customizing ps2mqtt.service:

```txt
  -h, --help                                  show this help message and exit
  --config CONFIG                             configuration file, will be created if non existing
  --period PERIOD                             updates period in seconds
  --mqtt-server MQTT_SERVER                   MQTT server
  --mqtt-port MQTT_PORT                       MQTT port
  --mqtt-username MQTT_USERNAME               MQTT username
  --mqtt-password MQTT_PASSWORD               MQTT password
  --mqtt-base-topic MQTT_BASE_TOPIC           MQTT base topic
  --ha-discover-prefix HA_DISCOVER_PREFIX     HA discover mqtt prefix
  --ha-status-topic HA_STATUS_TOPIC           HA status mqtt topic
  ```
  
You can also store all the options in a file, just run all your options plus the `--config /etc/ps2mqtt.yaml` to store all your parameters in a config file. Next time you run, just use `--config /etc/ps2mqtt.yaml`.
django-auth-jwks 1.0.1
Reusable Django library for JWT verification using JWKS with caching
Requires Python: >=3.8
Keywords: django, jwt, jwks, authentication, rest-framework

# django-auth-jwks

**django-auth-jwks** is a reusable Django app for verifying JWT tokens via JSON Web Key Sets (JWKS) with caching support. It is designed to work seamlessly with Django REST Framework (DRF) and supports both database-backed and stateless authentication scenarios.

> **Note**: This package is currently in **beta**. Features and APIs may change in future releases.

## Features

- **JWT Verification**: Validate JWT tokens using JWKS.
- **Stateless Authentication**: Supports servers without a database or user model.
- **Database Integration**: Maps JWT claims to Django user models when available.
- **Caching**: Efficiently caches JWKS for improved performance.
- **DRF Integration**: Works with Django REST Framework for API authentication.

## Installation

Install the package using pip:

```bash
pip install django-auth-jwks
```

Alternatively, for development purposes, you can install it in editable mode:

```bash
pip install -e .
```

To uninstall the package:

```bash
pip uninstall django-auth-jwks
```

## Quickstart

1. Add `django_auth_jwks` to your `INSTALLED_APPS` in `settings.py`:

   ```python
   INSTALLED_APPS = [
       ...,
       "django_auth_jwks",
   ]
   ```

2. Configure the `AUTH_JWKS` setting in your Django project to point to your JWKS URL:

   ```python
   AUTH_JWKS = {
        "ISSUER": "https://example.com",
        "JWKS_ENDPOINT": "/o/.well-known/jwks.json",
        "AUDIENCE": "example-service",
        "CACHE_TTL": 300,
    }
   ```

3. Use the `JWTAuthentication` class in your DRF settings:

   ```python
   REST_FRAMEWORK = {
       "DEFAULT_AUTHENTICATION_CLASSES": [
           "django_auth_jwks.authentication.JWTAuthentication",
       ],
   }
   ```

4. Optionally, use the `@require_auth` decorator or middleware for securing views.

5. Run your Django server:

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

## Usage

### Securing Views with the `@require_auth` Decorator

You can secure individual views by applying the `@require_auth` decorator:

```python
from django_auth_jwks.decorators import require_auth

@require_auth
def my_view(request):
    return JsonResponse({"message": "Authenticated!"})
```

### Using Middleware for Global Authentication

To apply authentication globally, add the middleware to your `MIDDLEWARE` setting:

```python
MIDDLEWARE = [
    ...,
    "django_auth_jwks.middleware.JWTAuthenticationMiddleware",
]
```

## Development

To contribute to this project:

1. Clone the repository.
2. Install dependencies:

   ```bash
   pip install -r requirements.txt
   ```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.

## Disclaimer

This package is in **beta**. Use it in production environments with caution, and report any issues you encounter.
pithermal 0.1.0a1
Python library for thermal cameras compatible with Raspberry Pi
Requires Python: >=3.9

<p align="center">
  <img width="100rem" src="https://github.com/taltstidl/pithermal/blob/main/docs/_static/logo.svg" />
  <h1 align="center">pithermal</h1>
</p>

[![build_docs](https://github.com/taltstidl/pithermal/actions/workflows/build_docs.yml/badge.svg)](https://github.com/taltstidl/pithermal/actions/workflows/build_docs.yml)

> [!NOTE]  
> This library is currently in active development and only supports the Meridian Innovation Cougar MI0802 thermal image sensor at the time of writing. Builds are not versioned or released on PyPI. Expect breaking changes.

The `pithermal` Python library is meant to be an easy and straightforward way to communicate with supported thermal imaging cameras on a Raspberry Pi, in intent similar to what `picamera2` offers for normal visual cameras. It takes just a few lines of code to capture your first thermal image:

```python
from pithermal import MeridianPiThermal

camera = MeridianPiThermal()
camera.capture_file('thermal.png')
```
neurons.me 0.1.3
Python package for neurons.me — enabling deep learning processes and modular neural computation.
Requires Python: >=3.6

<img src="https://res.cloudinary.com/dkwnxf6gm/image/upload/v1760895349/neurons.me-pip_dbdyvu.png" alt="neurons.me logo" width="244" height="244">

# neurons.me ∇

###### Go Algorithmic.

---

Welcome to the **neurons.me** python ecosystem. **DeepLearning** for Everyone, Everything, Anywhere and Anytime.

#### Explore our tools and libraries at:

[https://neurons.me](https://neurons.me/)

###### Contribution If you are interested in collaborating or wish to share your insights, please feel free to reach out.

**License**: MIT License. [Terms](https://docs.neurons.me/terms-and-conditions) | [Privacy](https://docs.neurons.me/privacy-policy)
queryshield 0.3.0
CLI for QueryShield
Requires Python: >=3.9

# queryshield

Command-line tool for database query performance analysis.

Analyze Django, SQLAlchemy, and FastAPI applications for N+1 queries, missing indexes, slow queries, and other performance issues.

## Installation

```bash
pip install queryshield
```

## Quick Start

```bash
# Analyze Django tests
queryshield analyze --framework django

# With API key to upload to SaaS
queryshield analyze --framework django --api-key sk_xxx

# Monitor production queries
queryshield production-monitor
```

## Features

- Multi-framework support (Django, SQLAlchemy, FastAPI)
- N+1 query detection
- EXPLAIN plan analysis
- Query budget enforcement
- SaaS integration for report storage
- Production query monitoring
- Performance regression detection
- AI-powered root cause analysis

## Configuration

Create a `queryshield.yml` in your project root:

```yaml
version: 1

# Test mode configuration
test:
  budget:
    query_count: 50
    total_time_ms: 1000
  enabled: true

# Production monitoring configuration
production:
  sample_rate: 0.01
  slow_query_threshold_ms: 500
  api_key: sk_xxx
  enabled: true
```

## Commands

- `queryshield analyze` - Analyze test queries
- `queryshield production-monitor` - Start production monitoring daemon
- `queryshield config` - Show current configuration

## Documentation

See the main [QueryShield documentation](https://queryshield.app/docs) for more information.
queryshield-probe 0.3.0
Django DB query probe for QueryShield
Requires Python: >=3.9

# queryshield-probe

Django database query performance probe for QueryShield.

Detect and analyze N+1 queries, missing indexes, slow queries, and other performance issues in Django tests and applications.

## Features

- N+1 query detection
- Missing index detection
- Query budget enforcement
- Performance regression detection
- Integration with pytest
- Integration with Django test runner
- Cloud cost estimation

## Installation

```bash
pip install queryshield-probe
```

## Usage

### Pytest Integration

```python
import pytest
from queryshield_probe import queryshield_pytest_plugin

@pytest.mark.queryshield
def test_user_queries(db):
    users = User.objects.all()
    for user in users:
        print(user.email)
```

### Django Settings

```python
INSTALLED_APPS = [
    'queryshield_probe',
]
```

## Documentation

See the main [QueryShield documentation](https://queryshield.app/docs) for more information.
queryshield-monitoring 0.2.0
QueryShield production monitoring middleware for FastAPI and Django
Requires Python: >=3.9

# queryshield-monitoring

Production database query monitoring middleware for QueryShield.

Monitor real-world database query performance in FastAPI and Django applications with minimal overhead.

## Features

- Low-overhead query sampling (configurable rate)
- Batch upload to SaaS backend
- Performance regression detection
- Slow query alerting
- Integration with FastAPI middleware
- Integration with Django middleware
- Slack notifications

## Installation

```bash
pip install queryshield-monitoring
```

## Usage

### FastAPI

```python
from fastapi import FastAPI
from queryshield_monitoring import QueryShieldMiddleware

app = FastAPI()

app.add_middleware(
    QueryShieldMiddleware,
    api_key="sk_...",
    sample_rate=0.01,
    slow_query_threshold_ms=500
)
```

### Django

```python
# settings.py
MIDDLEWARE = [
    'queryshield_monitoring.middleware.QueryShieldMiddleware',
]

QUERYSHIELD = {
    'API_KEY': 'sk_...',
    'SAMPLE_RATE': 0.01,
    'SLOW_QUERY_THRESHOLD_MS': 500,
}
```

## Documentation

See the main [QueryShield documentation](https://queryshield.app/docs) for more information.
queryshield-sqlalchemy 0.2.0
QueryShield probe for FastAPI and SQLAlchemy ORM
Requires Python: >=3.9

# queryshield-sqlalchemy

SQLAlchemy database query performance probe for QueryShield.

Detect and analyze N+1 queries, missing indexes, slow queries, and other performance issues in SQLAlchemy applications.

## Features

- N+1 query detection
- EXPLAIN plan analysis
- Missing index detection
- Query budget enforcement
- Integration with pytest
- Integration with FastAPI
- Multi-database support (PostgreSQL, MySQL, SQLite)

## Installation

```bash
pip install queryshield-sqlalchemy
```

## Usage

### Pytest Integration

```python
from queryshield_sqlalchemy import QueryShieldProbe

def test_user_queries(session):
    probe = QueryShieldProbe(session)
    
    users = session.query(User).all()
    for user in users:
        print(user.email)
    
    report = probe.finalize()
```

### FastAPI Integration

```python
from queryshield_sqlalchemy import FastAPIProbe

app = FastAPI()
probe = FastAPIProbe()

@app.get("/users")
def get_users(session: Session):
    users = session.query(User).all()
    return users
```

## Documentation

See the main [QueryShield documentation](https://queryshield.app/docs) for more information.
queryshield-core 0.2.0
QueryShield core analysis library - shared logic for all probe packages
Requires Python: >=3.9

# queryshield-core

Shared core logic for QueryShield - query analysis, EXPLAIN parsing, cost calculation, and budget checking.

This package contains the shared analysis engine used by all QueryShield probes (Django, SQLAlchemy, etc.).

## Features

- N+1 query detection
- EXPLAIN plan analysis (PostgreSQL, MySQL, SQLite)
- Cloud cost calculation (AWS, GCP, DigitalOcean)
- Budget enforcement and tracking
- AI-powered root cause analysis

## Installation

```bash
pip install queryshield-core
```

## Usage

```python
from queryshield_core.analysis import classify_problems
from queryshield_core.budgets import check_budget

# Analyze queries
problems = classify_problems(queries)

# Check budget
violations = check_budget(queries, budget_config)
```

## Documentation

See the main [QueryShield documentation](https://queryshield.app/docs) for more information.
mplcanvas 25.10.0
Matplotlib clone that draws on an ipycanvas
Requires Python: >=3.11

[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
[![PyPI badge](http://img.shields.io/pypi/v/mplcanvas.svg)](https://pypi.python.org/pypi/mplcanvas)
[![Anaconda-Server Badge](https://anaconda.org/conda-forge/mplcanvas/badges/version.svg)](https://anaconda.org/conda-forge/mplcanvas)
[![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)

# Mplcanvas

## About

Matplotlib clone that draws on an ipycanvas

## Installation

```sh
python -m pip install mplcanvas
```