semvec/pypi-packages huggingface dataset:
micropie 0.28
An ultra micro ASGI web framework
Keywords: micropie, asgi, microframework, http

[![Logo](https://patx.github.io/micropie/logo.png)](https://patx.github.io/micropie)

[MicroPie](https://patx.github.io/micropie) is an ultra-micro ASGI Python web framework for building fast, async web apps with minimal boilerplate. It includes convention-based routing, sessions, middleware, WebSocket support, lifespan hooks, and optional template rendering.

## Quick Start
```python
from micropie import App

class MyApp(App):
    async def index(self):
        return "Hello, MicroPie!"

app = MyApp()  # Run with `uvicorn app:app`
```

Run:

```bash
uvicorn app:app
```

## Installation

```bash
$ pip install micropie[standard]
```

Other profiles:

```bash
$ pip install micropie          # minimal
$ pip install micropie[all]     # standard + orjson + uvicorn
```

## Useful Links
- **Homepage**: [patx.github.io/micropie](https://patx.github.io/micropie)
- **Official Documentation**: [micropie.readthedocs.io](https://micropie.readthedocs.io/)
- **PyPI Page**: [pypi.org/project/MicroPie](https://pypi.org/project/MicroPie/)
- **GitHub Project**: [github.com/patx/micropie](https://github.com/patx/micropie)
- **Examples**: [github.com/patx/micropie/tree/main/examples](https://github.com/patx/micropie/tree/main/examples)
charmlibs-sysctl 1.0.0
The charmlibs.sysctl package.
Requires Python: >=3.10

# charmlibs.sysctl

The `sysctl` library.

To install, add `charmlibs-sysctl` to your Python dependencies. Then in your Python code, import as:

```py
from charmlibs import sysctl
```

See the [reference documentation](https://documentation.ubuntu.com/charmlibs/reference/charmlibs/sysctl) for more.
plover-touch-tablets 0.0.2
Touch Tablets Plover Plugin
Keywords: plover_plugin

# Plover Touch Tablets Plugin

This Plover plugin enables seamless integration between Plover and touch-based steno keyboard applications running on tablets. It establishes a secure WebSocket connection, allowing your tablet to function as a steno machine for Plover.

## Compatibility

This plugin is designed to be compatible with the **[Touch Steno Keyboard](https://github.com/CosmicDNA/touch-steno-keyboard)** application and the **[Plover Websocket Relay](https://github.com/CosmicDNA/plover-websocket-relay)**.

## Features

- **Easy Pairing**: Generates a QR code within Plover for quick connection setup.
- **Secure Connection**: Uses encryption to ensure secure communication between the tablet and Plover.
- **Bi-directional Communication**: Supports sending steno strokes to Plover and receiving dictionary lookups/translations back on the tablet.

## Installation

1. Open Plover.
2. Install `plover-touch-tablets` plugin via either plover_console CLI or plugin manager.
3. Restart Plover.

## Usage

1. Open Plover.
2. Go to **Tools** > **Tablet QR**.
3. A window will appear displaying a QR code.
4. Open the Touch Steno Keyboard application on your tablet.
5. Use the application to scan the QR code displayed on your computer screen.
6. Once connected, strokes entered on the tablet will be processed by Plover.

## Powered by
![Python](https://img.shields.io/badge/Python-repo?logo=python&color=black&style=for-the-badge)
![Plover](https://img.shields.io/badge/Plover-repo?logo=plover&color=black&style=for-the-badge)
sentry-streams-k8s 0.0.3
Kubernetes integration for Sentry Streams
Requires Python: >=3.11

# Sentry Streams K8s

Kubernetes integration for Sentry Streams.

Sentry Streams contains the streaming platform. That is everything that runs
the streaming applications. Sentry Streams is agnostic to the way the application
is deployed in production or in any environment.

This package instead provides the automation and the infrastructure to deploy
Sentry Streams in a Kubernetes environment.

At the moment it targets Sentry production environment that is based on
[sentry-kube](https://github.com/getsentry/sentry-infra-tools), though in the
future we expect to have something more Sentry agnostic like Helm charts and
a Kubernetes operator.

## The Consumer Macro

The main component is the Consumer macro. This is a sentry-kube external macro
that can be used inside the sentry-kube jinja template in the ops repo.
This takes the basic deployment infrastructure (application specific) and
fills it with containers and other resources to run the streaming platform.

The system to render a deployment would work this way:

```mermaid
graph LR
    subgraph sentry_streams_k8s
        consumer_macro[Consumer Macro]
        consumer_deployment[Consumer Deployment]
        config_map[Config Map]

        consumer_macro -- renders --> consumer_deployment
        consumer_macro -- renders --> config_map
    end

    subgraph ops_repo
        manifest[Manifest]
        deployment_template[Basic Deployment Template]
    end

    manifest -- imports --> deployment_template
    manifest -- imports --> consumer_macro
```

- The Consumer Macro renders all the Kubernetes resources to run the streaming
platform.
- The application manifest is responsible to create all the resources needed
  to run the application (like service accounts or additional config maps)
- The basic structure of the deployment template is application specific, it
  contains settings like labeling scheme and nodepool selectors. We expect these
  to be provided to the macro by the application in the form of the deployment
  template.
aide-dashboard 0.1.0
AI Developer Effectiveness dashboard — track your AI coding productivity
Requires Python: >=3.12
Keywords: ai, claude, dashboard, developer-tools, productivity

# aide

> AI Developer Effectiveness tool. Track your AI coding productivity across all projects.

aide ingests your Claude Code session logs and tells you what's happening: cost trends, token usage, session patterns, efficiency metrics, and actionable recommendations for improving your CLAUDE.md. The "Fitbit for AI coding."

## Why

The [METR study](https://metr.org/blog/2025-07-10-early-2025-ai-developer-productivity/) found developers believe AI makes them 20% faster but were actually 19% slower. Without data, you're guessing. aide gives you the data.

## Screenshots

![Overview — summary cards, effectiveness metrics, and trend charts](docs/screenshots/1-overview.png)

![Session detail — token breakdown, tool usage, files touched](docs/screenshots/5-session-detail.png)

![Insights — first-prompt analysis, time patterns, cost concentration](docs/screenshots/7-insights.png)

## Quick Start

```bash
pip install aide-dashboard    # or: git clone + uv sync
aide ingest                   # Parse your Claude Code logs into SQLite
aide serve                    # Open the dashboard at localhost:8787
aide autopsy <session-id>     # Diagnose a specific session
```

## What You Get

```
~/.claude/projects/**/*.jsonl → parser → SQLite → aide
```

aide reads Claude Code's local session logs (JSONL), parses them into a SQLite database, and provides multiple ways to analyze them:

- **Dashboard** (`aide serve`) — Web UI showing cost trends, session browser, project comparisons, and tool usage patterns across all your sessions
- **Session diagnostics** (`aide autopsy <id>`) — Per-session Markdown report with cost breakdown by category, context window analysis, compaction detection, and CLAUDE.md improvement suggestions
- **Quick stats** (`aide stats`) — Terminal summary of sessions, costs, and projects

Zero LLM calls. Zero cost to run. All data stays local.

## Commands

```bash
aide ingest              # Parse new/changed logs
aide ingest --full       # Rebuild database from scratch
aide serve               # Start dashboard at localhost:8787
aide serve --port 9000   # Custom port
aide stats               # Print summary to terminal
aide autopsy <id>        # Diagnose a specific session
```

## Configuration

Optional config at `~/.config/aide/config.yaml`:

```yaml
# Set to true if you're on Claude Pro/Max subscription
# Costs will show as "estimated equivalent at API rates"
subscription_user: false
```

## Data Privacy

All data stays on your machine. No telemetry, no cloud, no accounts. aide reads local log files and stores results in a local SQLite database.

## Development

```bash
git clone https://github.com/brianhliou/aide.git
cd aide
uv sync          # Install dependencies
uv run pytest    # Run tests (357 tests)
uv run aide serve   # Start dev server
```

## License

MIT