semvec/pypi-packages huggingface dataset:
pyarcscripts 0.0.10
Paquetage Python qui stocke toutes les fonctionnalités utiles de pyArc pouvant être utilisé dans tous projets et modules pyArc
Requires Python: >=3.7

# README

**pyarcscripts** est un paquetage Python pour gÃ©rer les configurations, l'internationalisation et les routes dans les applications FastAPI.

## Builder le projet

### Installations prÃ©alables

* **windows** : python -m pip install sdist bdist_wheel
* **linux** : sudo -H pip3 install sdist bdist_wheel

### Builder le projet

* **windows** : python setup.py sdist bdist_wheel
* **linux** : sudo py setup.py sdist bdist_wheel

### Deployer le projet sur pip

* **windows** : python -m twine upload dist/*
* **linux** : sudo twine upload dist/*

## Git

### Cloner le projet

git init && git remote add origin https://[username]@bitbucket.org/[username]/pypyarc.git && git config user.email [email] && git checkout -b [branche] && git pull origin [branche]

### Pousser le projet

git checkout [branche] && git add -A && git fetch && git merge [branche] && git commit -am "[le message commit]" && git push -u origin [branche]

## Tests

* **windows** : cls && python test.py
* **linux** : clear && python test.py

## Docstring

### Installations prÃ©alables

* **windows** : python -m pip install pdoc3
* **linux** : sudo -H pip3 install pdoc3

### Au prÃ©alable

Documenter aux prÃ©alables son code.

### Generer une documentation

* **windows** : python -m pdoc [projet]
* **linux** : sudo pdoc [projet]

### Exemple d'utilisation

```python 
from fastapi import FastAPI
from pyarcscripts import init_app, t, cfg, register_routes

app = FastAPI()
init_app()

# Use translations
print(t("hello.world"))  # Returns translation for "hello.world"

# Use configurations
print(cfg("database.url"))  # Returns configuration value for "database.url"

# Register routes
router = APIRouter()
register_routes(router, "path/to/routes")
app.include_router(router)
```

### Structure recommandÃ©e pour l'application utilisant ce package

```
arc_project/
â”œâ”€â”€ config.xml
â”œâ”€â”€ locales/
â”‚   â””â”€â”€ fr.json
â”œâ”€â”€ modules/
â”‚   â””â”€â”€ votre_module/
â”‚       â”œâ”€â”€ config.xml
â”‚       â””â”€â”€ locales/
â”‚           â””â”€â”€ fr.json
â””â”€â”€ routes/
    â””â”€â”€ vos_routes/
        â””â”€â”€ *.py
```
yahb 0.3.0
Yet another Python HTML builder
Requires Python: >=3.12

# Yet Another Python HTML Builder

A single-file, zero-dependency, fully-typed HTML builder library

### Usage:

```python
from yahb import (
    Document,
    Element,
    body,
    h1,
    head,
    html,
    img,
    link,
    main,
    meta,
    p,
    title,
)


def app() -> Element:
    return main(
        h1("Welcome to HTML Builder"),
        p(
            "Here's a cat for you:",
            img(src="https://cataas.com/cat"),
        ),
    )


doc = Document(
    html(
        head(
            meta(charset="UTF-8"),
            meta(name="viewport", content="width=device-width, initial-scale=1.0"),
            title("My Awesome Page"),
            link(rel="stylesheet", href="https://cdn.simplecss.org/simple.css"),
        ),
        body(app()),
        lang="en",
    )
)
print(doc)
```

Output:

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <title>
      My Awesome Page
    </title>
    <link rel="stylesheet" href="https://cdn.simplecss.org/simple.css"/>
  </head>
  <body>
    <main>
      <h1>
        Welcome to HTML Builder
      </h1>
      <p>
        Here&#x27;s a cat for you:
        <img src="https://cataas.com/cat"/>
      </p>
    </main>
  </body>
</html>
```
scrapli2 2.0.0b3
Fast, flexible, sync/async, Python 3.10+ screen scraping client specifically for network devices
Requires Python: >=3.10
Keywords: netconf, network, cli, ssh, telnet, async

<p center><a href=""><img src=https://github.com/carlmontanari/scrapli/blob/main/scrapli.svg?sanitize=true/></a></p>

[![Supported Versions](https://img.shields.io/pypi/pyversions/scrapli.svg)](https://pypi.org/project/scrapli)
[![PyPI version](https://badge.fury.io/py/scrapli.svg)](https://badge.fury.io/py/scrapli)
[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://opensource.org/licenses/MIT)

scrapli
=======

scrapli -- scrap(e c)li --  is a python 3.10+ library focused on connecting to devices, specifically network devices
 (routers/switches/firewalls/etc.) via Telnet, SSH or NETCONF.
paraglidetranslator 0.1.1
Translator for Paraglide JSONS based on DeepL API
Requires Python: <4.0,>=3.12

# Translator

Translator is a little, handy tool to manage the language files of a web application
using based on [paraglide](https://inlang.com/m/gerre34r/library-inlang-paraglideJs).
It uses a connection to [DeepL API](https://www.deepl.com/de/products/api). In order to use the
translator, You need at least a (free) account for the DeepL API. When You start up the translator
for the first time, it will ask for the DeepL API access key (See DeepL documentation how to get it)

## Usage of translator

After starting the translator app, You choose "OPEN" and select the directory where the
language specific JSON files are located (.../messages/en.json, .../messages/de.json etc.).
All the files will be read and displayed in a spreadsheet like manner.

### JSON input
For preparing the JSON file (which consists of a "key" for the text and the translation), e.g.
for german:
```json
{
  "$schema": "https://inlang.com/schema/inlang-message-format",
  "hello_world": "Hello, {name} from de-ch!",
  "unkown_api_error": "Unbekannter API-Fehler ({num})!"
}
```
If a key is not existing in a file, the corresponding field will be filled with
the key as "translated" value. The translation may be entered by hand, or
You can choose the base language and perform an automatic translation based
ön DeepL.

### Saving
Before saving, the "old" files are backuped with a name <lang>.XXX.json, where
XXX is a number 001, 002, 003, ...

The purge button removes *all* the backup files (for cleaning up).
clipipe 0.1.1
Send and receive data using human-readable codes
Requires Python: >=3.10
Keywords: bash, pipe, utilities

# Clipipe

Pronunciation: _Clip + Pipe_

`clipipe` is a command-line tool that allows you to pipe the output of one command to another machine. It works behind NAT and is designed to be used in shell pipelines, where the output of one command is passed as input to another command.

## How Does It Work?

`clipipe` reads data from standard input (stdin) and sends it to the server (also open source) via HTTPS. The server responds with a human-readable code, which you can share with others. The server stores the data on the server with an expiration time. On another machine, you can use `clipipe` to retrieve the data for the given code from the server and output it to standard output (stdout).

## Installation

You can install the CLI tool from PyPI:

```bash
pipx install clipipe
```

Or use `uv`:

```bash
uvx install clipipe
```

## User Guide

### Sending Data

Pipe any data to the server and receive a retrieval code:

```bash
echo "Hello World" | clipipe send
cat file.txt | clipipe send
tar cz file.txt | clipipe send
clipipe send < data.json
```

The server will respond with a code, for example: `bafilo42`. You can share this code with anyone who needs to retrieve the data.

### Retrieving Data

Use the code to fetch the data from the server:

```bash
clipipe receive bafilo42
clipipe receive bafilo42 > output.txt
clipipe receive bafilo42 | tar xz
```

### Checking Server Status

Check if the server is online:

```bash
clipipe status
```

### Custom Server

By default, `clipipe` connects to `https://clipipe.io`. To use a different server, set the `CLIPIPE_SERVER` environment variable or use the `--server` option:

```bash
export CLIPIPE_SERVER="https://your-clipipe-server.com"
clipipe send < file.txt
```

Or:

```bash
clipipe --server https://your-clipipe-server.com receive bafilo42
```

## Features

- Simple, human-readable codes for data retrieval.
- Works behind NAT and firewalls.
- Designed for shell pipelines to work with other tools.
- Open source server and client.
- Data stored temporarily with automatic expiration.

## Roadmap

- [ ] Built-in end-to-end encryption.
- [ ] Add HTTP streaming.
- [ ] Peer-to-peer support via WebRTC.

## License

MIT
tree-sitter-php 0.24.1
PHP grammar for tree-sitter
Requires Python: >=3.10
Keywords: incremental, parsing, tree-sitter, php

# tree-sitter-php

[![CI][ci]](https://github.com/tree-sitter/tree-sitter-php/actions/workflows/ci.yml)
[![discord][discord]](https://discord.gg/w7nTvsVJhm)
[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
[![crates][crates]](https://crates.io/crates/tree-sitter-php)
[![npm][npm]](https://www.npmjs.com/package/tree-sitter-php)
[![pypi][pypi]](https://pypi.org/project/tree-sitter-php)

PHP grammar for [tree-sitter](https://github.com/tree-sitter/tree-sitter).

[ci]: https://img.shields.io/github/actions/workflow/status/tree-sitter/tree-sitter-php/ci.yml?logo=github&label=CI
[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
[npm]: https://img.shields.io/npm/v/tree-sitter-php?logo=npm
[crates]: https://img.shields.io/crates/v/tree-sitter-php?logo=rust
[pypi]: https://img.shields.io/pypi/v/tree-sitter-php?logo=pypi&logoColor=ffd242
fast-blurhash 0.4.0
Minimal, fast BlurHash encoder/decoder for Python. A wrapper around the Rust fast-blurhash crate, with fully typed API and support for CPython 3.10–3.13.
Requires Python: >=3.10
Keywords: blurhash, image, rust, pyo3, ffi, bindings

### fast-blurhash

Minimal, fast BlurHash encoder/decoder for Python. A wrapper around the Rust [`fast-blurhash`](https://github.com/Sofiman/fast-blurhash) crate, with fully typed API and support for CPython 3.10–3.13.

### Install

```bash
uv add "fast-blurhash"
# If you want to use PIL functionality
uv add "fast-blurhash[pillow]"
```

### Usage

- **Encode from PIL.Image**
```python
from fast_blurhash import encode
from PIL import Image

with Image.open("image.png") as img:
    h = encode(img, x_components=4, y_components=3)
    print(h)  # e.g. "LEHV6nWB2yk8pyo0adR*.7kCMdnj"
```

- **Encode from raw bytes** (RGB or RGBA)
```python
from fast_blurhash import encode, PixelMode

# pixels: bytes of length width * height * channels
# e.g. Image.tobytes()
blurhash_str = encode(pixels, 4, 3, width=640, height=480, mode=PixelMode.RGB)
```

- **Decode to raw bytes (RGB)**
```python
from fast_blurhash import decode

pixels = decode("LEHV6nWB2yk8pyo0adR*.7kCMdnj", width=32, height=32)
# len(pixels) == 32 * 32 * 3
```

- **Decode to PIL.Image** (requires Pillow)
```python
from fast_blurhash import decode, DecodeType, PixelMode

img = decode("LEHV6nWB2yk8pyo0adR*.7kCMdnj", 32, 32, as_=DecodeType.PIL, mode=PixelMode.RGBA)
img.save("preview.png")
```