semvec/pypi-packages huggingface dataset:
moat-link-metrics-backend-akumuli 0.0.3
Akumuli backend for MoaT-Link metrics
Requires Python: >=3.13
Keywords: MoaT

# Akumuli backend for MoaT-Link metrics

% start synopsis
Akumuli time-series storage backend for moat-link-metrics.
% end synopsis

% start main

This package provides the Akumuli backend implementation for moat-link-metrics.
It allows forwarding metric values to an Akumuli time-series database.

## Installation

```shell
pip install moat-link-metrics-backend-akumuli
```

Or for Debian-based systems:

```shell
apt install moat-link-metrics-backend-akumuli
```

## Usage

The backend is automatically available once installed. To use it, set
`backend: akumuli` in your server configuration (this is the default).

## Configuration

The Akumuli backend supports the following configuration options in the
server config:

- **host**: Akumuli server hostname (default: `localhost`)
- **port**: Akumuli server port (default: `8282`)
- **delta**: Use delta compression (default: `true`)

## Example

```yaml
server:
  backend: akumuli
  host: localhost
  port: 8282
  delta: true
```

% end main
moat-lib-run 0.1.3
Main command entry point infrastructure for MoaT applications
Requires Python: >=3.8
Keywords: MoaT

# moat-lib-run

% start main
% start synopsis

Main command entry point infrastructure for MoaT applications.

% end synopsis

This module provides the infrastructure for building command-line interfaces
for MoaT applications. It includes:

- Command-line argument parsing with Click integration
- Subcommand loading from internal modules and extensions
- Configuration file handling
- Logging setup
- Main entry point wrappers for testing

## Usage

### Basic command setup

```python
from moat.lib.run import main_, wrap_main

@main_.command()
async def my_command(ctx):
    """A simple command"""
    print("Hello from my command!")
```

### Loading subcommands

Use `load_subgroup` to create command groups that automatically load subcommands:

```python
from moat.lib.run import load_subgroup
import asyncclick as click

@load_subgroup(prefix="myapp.commands")
@click.pass_context
async def cli(ctx):
    """Main command group"""
    pass
```

### Processing command-line arguments

The `attr_args` decorator and `process_args` function provide flexible
argument handling:

```python
from moat.lib.run import attr_args, process_args

@main_.command()
@attr_args(with_path=True)
async def configure(**kw):
    """Configure the application"""
    config = process_args({}, **kw)
    # config now contains parsed arguments
```

## Key Functions

- `main_`: The default main command handler
- `wrap_main`: Wrapper for the main command, useful for testing
- `load_subgroup`: Decorator to create command groups with automatic subcommand loading
- `attr_args`: Decorator for adding flexible argument handling to commands
- `process_args`: Function to process command-line arguments into configuration
- `Loader`: Click group class that loads commands from submodules and extensions

% end main
moat-lib-repl 0.1.4
An async readline re-implementation
Requires Python: >=3.12
Keywords: MoaT

# moat-lib-repl

% start main
% start synopsis

A straightforward async-ization of `pyrepl`.

% end synopsis

This module was copied from CPython v3.13.9 and anyio-ized.

## Usage

```python
from moat.lib.repl import multiline_input
async def main():
        inp = await multiline_input(lambda s: "\n" not in s, "=== ","--- ")
        print("RES:",repr(inp))

anyio.run(main)
```

% end main

## License

Licensed under (something like) the
[MIT License](https://github.com/python/cpython/blob/3.13/Lib/_pyrepl/__init__.py)
moat-link-metrics-backend-victoria 0.0.3
VictoriaMetrics backend for MoaT-Link metrics
Requires Python: >=3.13
Keywords: MoaT

# VictoriaMetrics backend for MoaT-Link metrics

% start synopsis
VictoriaMetrics time-series storage backend for moat-link-metrics.
% end synopsis

% start main

This package provides the VictoriaMetrics backend implementation for moat-link-metrics.
It allows forwarding metric values to a VictoriaMetrics time-series database.

## Installation

```shell
pip install moat-link-metrics-backend-victoria
```

Or for Debian-based systems:

```shell
apt install moat-link-metrics-backend-victoria
```

## Usage

The backend is automatically available once installed. To use it, set
`backend: victoria` in your server configuration.

## Configuration

The VictoriaMetrics backend supports the following configuration options in the
server config:

- **host**: VictoriaMetrics server hostname (default: `localhost`)
- **port**: VictoriaMetrics server port (default: `8282`)
- **delta**: Use delta compression (default: `true`)

## Example

```yaml
server:
  backend: victoria
  host: localhost
  port: 8282
  delta: true
```

% end main
moat-link-metrics 0.0.4
Metrics time-series connector for MoaT-Link
Requires Python: >=3.13
Keywords: MoaT

# Metrics time-series connector

% start synopsis
Forwards MoaT-Link values to metrics time-series storage backends.
% end synopsis

% start main

This module watches MoaT-Link entries and writes their values to metrics backends
whenever they change. It replaces the legacy ``moat-kv-akumuli`` and ``moat-link-akumuli`` packages.

## Features

- Pluggable backend support (currently: Akumuli)
- Per-server configuration stored in MoaT-Link
- Dynamic series management: add, remove, or modify series at runtime
- Configurable scaling (factor/offset) and rate limiting (t_min)
- Attribute extraction from nested source values

## Quick start

1. Configure a metrics server:

   ```shell
   moat link metrics add myserver my.entry source.path series_name host=myhost
   ```

2. Run the connector:

   ```shell
   moat link metrics monitor myserver
   ```

## Backends

The default backend is Akumuli. To specify a different backend, set the `backend`
field in the server configuration to the backend module name (e.g., `akumuli`).

## Deprecation

This package supersedes ``moat-kv-akumuli`` and ``moat-link-akumuli``.  The raw
MQTT topic monitoring feature has been removed; use MoaT-Link's native data paths instead.

% end main
epita-coding-style 2.4.2
EPITA C Coding Style Checker - validates C code against EPITA coding standards
Requires Python: >=3.10
Keywords: c, checker, coding-style, epita, linter

# EPITA C Coding Style Checker

A fast C linter for EPITA coding style rules. Uses [tree-sitter](https://tree-sitter.github.io/) for robust AST-based parsing.

## Installation

```bash
pipx install epita-coding-style
```

## Quick Start

```bash
epita-coding-style src/           # Check files/directories
epita-coding-style --list-rules   # List all rules with descriptions
epita-coding-style --show-config  # Show current configuration
epita-coding-style --help         # Full usage info
```

## Configuration

Configuration is auto-detected from (in order):
- `.epita-style`
- `.epita-style.toml`
- `epita-style.toml`
- `[tool.epita-coding-style]` in `pyproject.toml`

**Priority:** CLI flags > config file > preset > defaults

### Generate a Config File

```bash
epita-coding-style --show-config --no-color > .epita-style.toml
```

This outputs a complete, commented TOML config you can customize.

### Presets

```bash
epita-coding-style --preset 42sh src/      # 40 lines, goto/cast allowed
epita-coding-style --preset noformat src/  # Same + skip clang-format
```

### Example Config

```toml
# .epita-style.toml
max_lines = 40

[rules]
"keyword.goto" = false  # Allow goto
"cast" = false          # Allow casts
```

Or in `pyproject.toml`:

```toml
[tool.epita-coding-style]
max_lines = 40

[tool.epita-coding-style.rules]
"keyword.goto" = false
```

## clang-format

The `format` rule uses `clang-format` to check code formatting. Requires `clang-format` to be installed.

The checker looks for `.clang-format` in the file's directory (walking up to root), or uses the bundled EPITA config.

To disable: set `"format" = false` in your config, or use `--preset noformat`.

## Pre-commit Hook

```yaml
# .pre-commit-config.yaml
repos:
  - repo: https://github.com/KazeTachinuu/epita-coding-style
    rev: v2.3.0
    hooks:
      - id: epita-coding-style
        args: [--preset, 42sh]  # optional
```

## License

MIT
iis-kix 3.8.2
Example Python Module
Requires Python: >=3.10

# Example Package

This is used to upload dummy packages to Pypi.

This is a simple example package. You can use
[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content.

To upload a new package to public pypi repository update the pyproject.toml file and give it a name.

Run these commands to upload

```bash
pip install build twine
twine upload dist/*
```

Twine will ask for token then provide the token from the Pypi account.
pykickstart 3.69
Python module for manipulating kickstart files
Requires Python: >=3.6

Pykickstart
===========

Pykickstart is a Python 2 and Python 3 library consisting of a data
representation of kickstart files, a parser to read files into that
representation, and a writer to generate kickstart files.

Online documentation
--------------------

Online documentation for kickstart and the Pykickstart library is available on Read the Docs:
https://pykickstart.readthedocs.io

How to generate the kickstart documentation
-------------------------------------------

The pykickstart documentation is generated dynamically from the source code with Sphinx.

To generate the documentation first make sure you have the Python bindings for Sphinx installed.
At least on Fedora this means installing the ``python3-sphinx`` package.

Then change directory to the ``docs`` folder:

``cd docs``

And generate the docs with:

``make html``
libelifoot 0.1.1
Library to handle Elifoot equipas
Requires Python: >=3.11

## libelifoot

[![CI](https://github.com/andrelcmoreira/libelifoot/actions/workflows/ci.yaml/badge.svg)](https://github.com/andrelcmoreira/libelifoot/actions/workflows/ci.yaml)
[![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)

### Overview

Library to handle Elifoot 98 equipas. The main functionalities of the library are:

- View data from a equipa file;
- Generate patch files with upstream data from an equipa file;
- Generate patches in batch from a directory of equipa files.

### Usage

View the content of an equipa file:

```python
from sys import argv

from libelifoot import view_equipa


def main(equipa: str) -> None:
    print(view_equipa(equipa))


if __name__ == "__main__":
    main(argv[1])
```

Generate a patch file with upstream data from an equipa file:

```python
from sys import argv
from typing import Optional

from libelifoot import (
    update_equipa,
    Equipa,
    EquipaFileHandler,
    UpdateEquipaListener
)


class EventHandler(UpdateEquipaListener):

    def on_update_equipa(
        self,
        equipa_name: str,
        equipa_data: Optional[Equipa]
    ) -> None:
        print(f'{equipa_name}\n{equipa_data}')

        if equipa_data:
            EquipaFileHandler.write(f'{equipa_name}.patch', equipa_data)

    def on_update_equipa_error(self, error: str) -> None:
        print(f'ERROR: {error}')


def main(equipa: str, provider: str, season: int) -> None:
    ev = EventHandler()

    update_equipa(equipa, provider, season, ev)


if __name__ == "__main__":
    main(argv[1], argv[2], int(argv[3]))
```

Generate patches in batch based on a directory of equipa files:

```python
from sys import argv
from typing import Optional

from libelifoot import (
    bulk_update,
    Equipa,
    EquipaFileHandler,
    UpdateEquipaListener,
)


class EventHandler(UpdateEquipaListener):

    def on_update_equipa(
        self,
        equipa_name: str,
        equipa_data: Optional[Equipa]
    ) -> None:
        print(f'{equipa_name}\n{equipa_data}')

        if equipa_data:
            EquipaFileHandler.write(f'{equipa_name}.patch', equipa_data)

    def on_update_equipa_error(self, error: str) -> None:
        print(f'ERROR: {error}')


def main(equipa_dir: str, provider: str, season: int) -> None:
    ev = EventHandler()

    bulk_update(equipa_dir, provider, season, ev)


if __name__ == "__main__":
    main(argv[1], argv[2], int(argv[3]))
```

### Supported providers

To generate patches, the library fetches data from public football data providers. Currently, the library supports the following providers:

- ESPN;
- Transfermarkt.

### Documentation

See [docs](https://github.com/andrelcmoreira/libelifoot/tree/develop/docs).
pytest-ty 0.1.5
A pytest plugin to run the ty type checker
Requires Python: >=3.10

pytest-ty
[![Build Status](https://github.com/boidolr/pytest-ty/actions/workflows/main.yaml/badge.svg)](https://github.com/boidolr/pytest-ty/actions/workflows/main.yaml "See Build Status on GitHub Actions")
[![pypi](https://img.shields.io/pypi/v/pytest-ty.svg)](https://pypi.org/project/pytest-ty/ "See PyPI page")
![python](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fboidolr%2Fpytest-ty%2Fmain%2Fpyproject.toml)
=========

A [`pytest`](https://github.com/pytest-dev/pytest) plugin to run the [`ty`](https://github.com/astral-sh/ty) type checker.


Configuration
------------

Configure `ty` in `pyproject.toml` or `ty.toml`,
see the [`ty` documentation](https://docs.astral.sh/ty/).


Installation
------------

You can install `pytest-ty` from [`PyPI`](https://pypi.org):

* `uv add --dev pytest-ty`
* `pip install pytest-ty`

Usage
-----

* Activate the plugin when running `pytest`: `pytest --ty`
* Activate via `pytest` configuration: `addopts = "--ty"`


License
-------

`pytest-ty` is licensed under the MIT license ([`LICENSE`](./LICENSE) or https://opensource.org/licenses/MIT).