semvec/pypi-packages huggingface dataset:
rtfunicode 2.3
Encoder for unicode to RTF 1.5 command sequences
Requires Python: >=3.10
Keywords: rtf

# Unicode to RTF command code conversion

[![PyPI version](https://img.shields.io/pypi/v/rtfunicode.svg)](https://pypi.python.org/project/rtfunicode)
[![License](https://img.shields.io/pypi/l/rtfunicode.svg)](https://github.com/mjpieters/rtfunicode/blob/main/LICENSE.txt)
![Python versions supported](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fmjpieters%2Frtfunicode%2Fmain%2Fpyproject.toml)
[![Built with uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
[![Checked with Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Checked with Pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
[![Python checks](https://github.com/mjpieters/rtfunicode/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/mjpieters/rtfunicode/actions/workflows/ci-cd.yml)
[![Coverage](https://codecov.io/gh/mjpieters/rtfunicode/graph/badge.svg?token=ZRZO4XRBP6)](https://codecov.io/gh/mjpieters/rtfunicode)

This module implements an encoder for unicode to RTF 1.5 command sequences; it
can be used to generate valid RTF output with international characters.

Importing this module adds a new `rtfunicode` codec, allowing you to encode
unicode strings to valid RTF bytecode sequences:

```pycon
>>> import rtfunicode
>>> 'RTF and unicode mix just fine! \u263A'.encode('rtfunicode')
'RTF and unicode mix just fine! \\u9786?'
```

The RTF command code for a unicode character is `\uN?`, where N is a signed
16-bit integer and the ? is a placeholder character for older RTF readers. This
module sets the latter to the '?' literal for simplicity's sake.

## Requirements

* Python 3.10 or newer.


## Development

The project code is hosted on [GitHub][], feel free to report issues,
fork the code and issue pull requests.

[GitHub]: https://github.com/mjpieters/rtfunicode

This project uses [`uv`](https://docs.astral.sh/uv/) to handle Python dependencies and environments; use `uv sync` to get an up-to-date virtualenv with all dependencies. This includes development dependencies such as [Ruff](https://docs.astral.sh/ruff/) (used for linting and formatting) and [Pyright](https://microsoft.github.io/pyright/) (used to validate type annotations).

### Linting and formatting

While PRs and commits on GitHub are checked for linting and formatting issues, it's easier to check for issues locally first. After running `uv sync`, run `uv run pre-commit install` to install [pre-commit](https://pre-commit.com/) hooks that will run these tools and format your changes automatically on commits. These hooks also run `uv sync` whenever your working tree changes.

### Testing

This project uses `pytest` to run its tests: `uv run pytest`.

## License

BSD 2-Clause (simplified), see: [LICENSE.txt](./LICENSE.txt)


## Author

Martijn Pieters <mj@zopatista.com>
easy-px4-utils 0.1.5
Utility functions for easy-px4
Requires Python: >=3.9
Keywords: PX4, firmware, uav, drone, cli, utils

# `easy-px4-utils`

Set of utility function to parse information.

> [!IMPORTANT]
> This is a core, and critical package for our package: [`eolab_drones`](https://github.com/EOLab-HSRW/drones-fw/tree/main).
t-level 1.0.0
Command line utility for calculating the t-level achieved by running a given number of ECM curves.
Requires Python: >=3.9

# t-level

Command line utility for calculating the t-level achieved by running a given number of ECM curves.

## Installation

### Using uv (Recommended)

```bash
uv tool install t-level
```

### Using pip

```bash
pip install t-level
```

## Binary Releases

Standalone binaries for Linux and Windows are available on the [GitHub Releases page](https://github.com/brubsby/t-level/releases).

There are two versions available for each platform:

1.  **Directory Version (Recommended for Speed):**
    *   **Filename:** `t-level-{os}-dir.zip`
    *   **Startup Speed:** Instant (~0.2s).
    *   **Format:** A zip file containing a folder. You must extract it and run the `t-level` executable inside.
    
2.  **Portable Version (Single File):**
    *   **Filename:** `t-level-{os}-portable` (Linux) or `t-level-{os}-portable.exe` (Windows)
    *   **Startup Speed:** Slower (~0.7s delay on every run).
    *   **Format:** A single executable file. Easier to share, but requires unpacking internal data to a temporary directory on every execution.

## Usage

```bash
echo <curve_string>[;<curve_string>][...] | t-level [options]
printf <curve_string>[\n<curve_string>][...] | t-level [options]
t-level [options] < <input_file>
t-level [options] -i <input_file>
t-level [options] -q"<curve_string>[;<curve_string>][...]"
```

`<curve_string>` must fully match the regex:
`\s*(\d+e\d+|\d+)(?:\/(\d+e\d+|\d+))?@(?:B1=)?(\d+e\d+|\d+)(?:,\s*(?:B2=)?(\d+e\d+|\d+))?(?:,\s*(?:(?:param|p)=)?([0-4]))?\s*`

Examples:
- `5208@11e6`
- `5208@11e6,35133391030,1`
- `5208@11e6,35e9,p=3`
- `5208@B1=11e6,B2=35e9,param=0`
- `5208/8192@11e6`  # 5208 finished curves, 2984 stage-1 curves

Multiple curve strings must be delimited by semicolons or newlines.

## Options

See `t-level --help` for more details.
graphite-render 1.1.8
based on graphite-api, which is based graphite-web, but maintained for python3.
Requires Python: >=3.9
Keywords: graphite, api, monitoring, visualization

Graphite-Render
===============

**Note:** This is a maintained friendly fork of the upstream project at
https://github.com/brutasse/graphite-api.

Graphite-web, without the interface. Just the rendering HTTP API.

This is a minimalistic API server that replicates the behavior of
Graphite-web. I removed everything I could and simplified as much code as
possible while keeping the basic functionality.

Implemented API calls:

* ``/metrics/find``
* ``/metrics/expand``
* ``/render``

No-ops:

* ``/dashboard/find``
* ``/dashboard/load/<name>``
* ``/events/get_data``

Difference from graphite-web
----------------------------

* Stateless. No need for a database.
* No Pickle rendering.
* No remote rendering.
* JSON data in request bodies is supported, additionally to form data and
  querystring parameters.
* Ceres integration will be as an external backend.
* Compatibility with python 3.
* Easy to install and configure.

Goals
-----

* Solid codebase. Good test coverage.
* Ease of installation/use/configuration.
* Compatibility with the original Graphite-web API and 3rd-party dashboards.

Non-goals
---------

* Support for very old Python versions
* Built-in support for every metric storage system in the world. Whisper is
  included by default, other storages are added via 3rd-party backends.

Documentation
-------------

In the ``docs/`` directory.

Hacking
-------

`Tox`_ is used to run the tests for all supported environments. To get started
from a fresh clone of the repository:

.. code-block:: bash

    pip install tox
    tox

.. _Tox: https://testrun.org/tox/
graph-generator-assistant 0.1.4
Program that assists in generating professional graphs.
Requires Python: >=3.8
Keywords: writing, translate

# graph-generator-assistant

Program that assists in generating professional graphs.

![logo](https://raw.githubusercontent.com/trucomanx/GraphGeneratorAssistant/main/screenshot.png)

## 1. Installing

To install the package from [PyPI](https://pypi.org/project/graph_generator_assistant/), follow the instructions below:


```bash
pip install --upgrade graph-generator-assistant
```

Execute `which graph-generator-assistant` to see where it was installed, probably in `/home/USERNAME/.local/bin/graph-generator-assistant`.

### Using

To start, use the command below:

```bash
graph-generator-assistant
```

## 2. Buy me a coffee

If you find this tool useful and would like to support its development, you can buy me a coffee!  
Your donations help keep the project running and improve future updates.  

[☕ Buy me a coffee](https://ko-fi.com/trucomanx) 

## 3. License

This project is licensed under the GPL license. See the `LICENSE` file for more details.
conferencemapper 1.0.1
Jigasi ConferenceMapper with Redis, Flask and Gunicorn
Requires Python: >=3.9

Simple Jigasi ConferenceMapper with Redis, Flask and Gunicorn
=============================================================

This implements the /conferenceMapper part of https://github.com/jitsi/jitsi-meet/blob/master/resources/cloud-api.swagger

Prerequisites: Redis, redis-py, flask and a wsgi server like gunicorn

Packages for Ubuntu Server 24.04

    apt install python3-flask gunicorn redis-server, python3-redis

Copy conferencemapper.service and conferencemapper.socket to /etc/systemd/system

Adapt /etc/systemd/system/conferencemapper.service to match WorkingDirectory to conferencemapper module directory.

Add reverse proxy in front of gunicorn (nginx)

    location = /conferenceMapper {
        proxy_pass http://127.0.0.1:8001/conferenceMapper?$query_string;
    }

Start it and activate nginx config

    systemctl daemon-reload
    systemctl enable conferencemapper.socket
    systemctl start conferencemapper.socket
    systemctl reload nginx

## Development and Testing

To install the package with test dependencies:

    pip install -e ".[test]"

To run the tests:

    pytest tests/

Or with verbose output:

    pytest tests/ -v
Westerlund 0.1.1
Westerlund: Westerlund ECM Panel Cointegration Test.
Requires Python: >=3.8

# Westerlund: Panel Cointegration Testing in Python

`Westerlund` is a Python package implementing a functional approximation of the four panel cointegration tests developed by **Westerlund (2007)**. The Westerlund test evaluates the null hypothesis of **no cointegration** by testing whether the error-correction term in a conditional panel ECM is equal to zero. If the null is rejected, there is evidence of a long-run equilibrium relationship between the variables.

## Key Features

The package replicates the logic of the Westerlund (2007) methodology, including:
* **Four Test Statistics**: Computes $G_t$, $G_a$, $P_t$, and $P_a$.
* **Flexible Dynamics**: Allows for unit-specific lag and lead lengths.
* **Automated Selection**: Built-in AIC/BIC selection logic for optimal lag and lead lengths.
* **Bootstrap Procedure**: Robust p-values to handle cross-sectional dependence.
* **Kernel Estimation**: Bartlett kernel long-run variance estimation.
* **Gap Handling**: Strict time-series continuity checks to ensure valid econometric results.



## Usage Examples
```python
import pandas as pd
from westerlund_test import WesterlundTest

# 1. Prepare your panel data (Long format)
# Required columns: ID, Time, Y, X1, X2...
df = pd.read_csv("your_data.csv")

# 2. Initialize the test
test = WesterlundTest(
    data=df, 
    y_var='log_gdp', 
    x_vars=['log_energy', 'log_capital'], 
    id_var='country_id', 
    time_var='year',
    lags=(0, 2),        # Auto-select lags between 0 and 2
    leads=(0, 1),       # Auto-select leads between 0 and 1
    constant=True,      # Include intercept
    trend=True,         # Include time trend
    bootstrap=100,      # Perform 100 bootstrap replications
    seed=42
)

# 3. Run the estimation
results = test.run()

# 4. Visualize the results
test.plot_bootstrap()
```

## References
Westerlund, J. (2007). Testing for Error Correction in Panel Data. Oxford Bulletin of Economics and Statistics, 69(6), 709-748.

Persyn, D., & Westerlund, J. (2008). Error-Correction-Based Cointegration Tests for Panel Data. Stata Journal, 8(2), 232-241.
opendma-api 0.8.0
Python API for OpenDMA
Requires Python: >=3.9

# OpenDMA API for Python

At it's core, OpenDMA (Open Document Management Architecture) defines an
abstract model for Document Management and Enterprise Content Management
Systems.

The OpenDMA API provides an abstract interface to this model. It allows
to write content centric applications once, and run them against multiple
different Enterprise Content and Document Management Systems.

The API is available for different programming languages and enforces a
consistent style across these languages.

This repository contains the OpenDMA API for Python.

It has been auto-generated by the [OpenDMA API Builder](https://github.com/OpenDMA/opendma-api-builder).

## Installation

This project is available on [PyPI](https://pypi.org/). You can simply install it with pip:
```
pip install opendma-api
```

## Usage

The OpenDMA API defines a set of interfaces (ABCs in python) that need to be implemented by an
OpenDMA Adaptor for an actual ECM system -- very similar to database drivers.

There is a generic [OpenDMA REST Client for Python](https://github.com/OpenDMA/opendma-python-remote)
implementing this API on top of the [OpenDMA REST API](https://github.com/OpenDMA/opendma-spec/blob/main/opendma-rest-api-spec.yaml).
With the help of REST-ful servers and clients it is possible to bridge programming language and network boundaries.

You can find multiple examples for Python in the [OpenDMA REST Client for Python](https://github.com/OpenDMA/opendma-python-remote) repository.

There is also a complete [OpenDMA Tutorial for Java](https://github.com/OpenDMA/opendma-java-tutorial)
showing the basic concepts which apply to Python as well.
shehzaib007 0.1.0
A simple utility package with basic math and string operations
Requires Python: >=3.7
Keywords: math string operations utility

# shehzaib007

A simple utility package providing basic math and string operations.

## Features

- **Math Operations Module**: Functions for basic mathematical calculations
  - `square(x)` - Calculate the square of a number
  - `cube(x)` - Calculate the cube of a number
  - `add(a, b)` - Add two numbers
  - `multiply(a, b)` - Multiply two numbers

- **String Operations Module**: Functions for basic string manipulation
  - `reverse_string(text)` - Reverse a string
  - `count_vowels(text)` - Count vowels in a string
  - `to_uppercase(text)` - Convert string to uppercase
  - `word_count(text)` - Count words in a string

## Installation

You can install shehzaib007 from PyPI using pip:

```bash
pip install shehzaib007
```

## Usage

### Math Operations

```python
from shehzaib007 import square, cube, add, multiply

# Calculate square
result = square(5)  # Returns 25

# Calculate cube
result = cube(3)  # Returns 27

# Add numbers
result = add(10, 5)  # Returns 15

# Multiply numbers
result = multiply(4, 7)  # Returns 28
```

### String Operations

```python
from shehzaib007 import reverse_string, count_vowels, to_uppercase, word_count

# Reverse a string
result = reverse_string("hello")  # Returns "olleh"

# Count vowels
result = count_vowels("hello world")  # Returns 3

# Convert to uppercase
result = to_uppercase("hello")  # Returns "HELLO"

# Count words
result = word_count("hello world python")  # Returns 3
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Shehzaib

## Version

0.1.0
maler 0.1.1
Add your description here
Requires Python: >=3.10

# Maler

A Python templating library for rendering dynamic HTML and MJML content in a type-safe way.

## Why Maler?

"Maler" is Norwegian for both "painters" and "templates" — fitting for a library that helps you paint your pages with reusable templates.

## Installation

```bash
uv add maler
```

Or with pip:

```bash
pip install maler
```

## Quick Start

Create your first template:

```python
from maler import div, span

my_page = div(
    "Hello ", span("World", class_="font-bold")
).render()
```

## Dynamic Content

Use the `@template` decorator for safe-dynamic content.
This will escape unsafe HTML content:

```python
from maler import div, span, template

@template
def hello_world(name: str | None = None):
    return div(
        "Hello ", span(name or "World", class_="font-bold")
    )

html = hello_world(name="<script>a_bad_script=...</script>")
```
Leading to the following:
```
<div>Hello <span class="font-bold">&lt;script&gt;a_bad_script...</span></div>
```

## FastAPI Integration

Maler integrates seamlessly with FastAPI using the `render_template` decorator:

```python
from fastapi import FastAPI
from maler import div, h1
from maler.fastapi import render_template

app = FastAPI()

def page_template(user: User):
    return div(
        h1("Welcome, ", user.name)
    )

def error_template(error: Exception):
    return div("Something went wrong!")

@app.get("/user/{user_id}")
@render_template(page_template, error_template)
async def get_user(user_id: int):
    return await fetch_user(user_id)
```

The decorator automatically returns an `HTMLResponse`. If the client sends `Accept-Encoding: application/json` will it return JSON instead.

## MJML Support

Create responsive emails using [MJML](https://mjml.io) syntax with the `@mjml_template` decorator:

```python
from maler.mjml import mjml_template
from maler.mjml_tags import mjml, mj_body, mj_section, mj_column, mj_text
from maler import Tag

@mjml_template
def welcome_email(name: str):
    return mjml(
        mj_body(
            mj_section(
                mj_column(
                    mj_text(f"Welcome, {name}!")
                )
            )
        )
    )

html = welcome_email("Alice")
```

This requires the `mrml` package for MJML-to-HTML conversion.