semvec/pypi-packages huggingface dataset:
fasttlogparser 1.1.1
Blazing-Fast MAVLink .tlog Parser
Requires Python: >=3.10

# ⚡ fasttlogparser - Blazing-Fast MAVLink .tlog Parser

[![codecov](https://codecov.io/gh/Bogdanov-am/fasttlogparser/graph/badge.svg?token=UNPLPI04DR)](https://codecov.io/gh/Bogdanov-am/fasttlogparser)
![test](https://github.com/Bogdanov-am/fasttlogparser/actions/workflows/python-test.yml/badge.svg)
[![PyPI version](https://badge.fury.io/py/fasttlogparser.svg)](https://badge.fury.io/py/fasttlogparser)

**Unlock lightning-fast MAVLink telemetry parsing** with this Python package powered by optimized C++ backend. Extract insights from .tlog files at unparalleled speeds!

```python
import fasttlogparser

# Parse entire file
messages, msg_ids = fasttlogparser.parseTLog("flight.tlog")

# Advanced: Filter messages + remap fields
results = fasttlogparser.parseTLog(
    path = "mission.tlog",
    ids = [(1,1)],                              # Specific MAVLink IDs
    whitelist = ["GPS_RAW_INT", "ATTITUDE"],    # Keep only these messages
    blacklist = ["AUTOPILOT_VERSION"],          # Exclude these messages
    remap_field = {"alt": "altitude"}           # Rename fields
)
```

## ✨ Key Features

- **Native C++ acceleration** - ~100x faster than pure Python parser
- **Smart filtering** - by system_id/componet_id or message name whitelist/blacklist
- **Field remapping** - customize output schema
- **Zero dependencies** - lightweight Python bindings via pybind11

## ⚙️ Installation

```bash
pip install fasttlogparser --no-build-isolation
```

## 🔧 Advanced Usage

Filter messages using MAVLink IDs:

```python
# Get only GPS_RAW_INT and ATTITUDE messages
messages = fasttlogparser.parseTLog("data.tlog", whitelist=["GPS_RAW_INT", "ATTITUDE"])
```

Filter messages using system and component IDs:

```python
# Keep only (2,1) - (sysId, cmpId)
results = fasttlogparser.parseTLog("long_flight.tlog", ids = [(2,1)])
```

Rename individual message fields:

```python
results = fasttlogparser.parseTLog("long_flight.tlog", remap_field = {"alt": "altitude"})
```

## ⚡ Benchmark

Processing a 252MB .tlog file:

- Pure Python parser: 24m 56s ⏳
- **fasttlogparser**: 16.6s ⚡ _(90x faster!)_

---

### Ready for high-performance telemetry MAVLink analysis?
qtlets 0.4
Qt with less boilerplate
Requires Python: >=3.8
Keywords: qt, qtwidgets, pyside6, gui

# qtlets
Automatic linking of data to qt widgets. MCV without the boilerplate.

`qtlets` provides a simple way to keep in sync Qt widgets and data, without 
forcing a redesign of your data classes. The rule is: *if you like your class, you can
keep your class*. 

Currently, bidirectional linking can be performed in a simple call<sup>1</sup>:
`instance.link_widget(my_widget, "name")`
The data displayed on `my_widget` will be updated whenever `instance.name` is
modified. Changing the value on `my_widget` will update `instance.name`. 
Multiple widgets can be kept synchronized in this way.
 
This functionnality is provided by a lightweight Mixin class called `HasQtlets`.
To enable `qtlets` on an `Existing` class, simply do:
```
class Data(HasQtlets, Existing): pass
``` 
and then use `Data` as a drop-in replacement for `Existing`. To link widgets,
make calls to `link_widget`. The widget should be able to send and receive the
appropriate data type. A few basic types are availalbe in `qtlets.widgets`


This library is currently in early stages. The documentation is light, and 
the API is changing quickly. All help is appreciated...

<sup>1</sup> Some conditions currently apply, see the Features section.

# Getting started

Requires an environment with python 3.8.

## Install dependencies
```
pip install -r requirements.txt
pip install -e .
```

## Run tests
`py.test`

# Features

The following features are currently supported:
- Linking of widgets and data. Currently, scalar data members are supported;
- Multiple widgets can be linked with the same data attribute;
- Compatibility with simple vanilla classes, as well as more complex 
  third-party libraries such as `traitlets` (Even `attrs`! Isn't inheritance 
  wonderful?);
- Support for `properties`;
- The signal and slots used to communicate with the widget can be specified
  explicitly. For some widgets, a reasonable default is provided. 


The following features are desired:
- Adding more data types and widgets.
- Streamlined type conversions and checks. For type conversion, we can pass
  conversion functions to `link_widget`.
- Support for collections attributes (ex: `instance.values = []`)
- Support polling (`inst.link(widget, attrname, poll_interval=15)`)
- Leverage Qt's thread affinity when using signals and slots, for setting as 
  well as for getting. 
- More dedicated widgets.
- Use either PySide6 or PyQt. See how pyqtgraph does it.
helloto 1.0.1
For saying hello.


# Helloto

This project can say hello to your subject very clever and easy in different ways.

## Installation

The installation proccess can be done using the pip tool:
```
pip install helloto
```

### Project Link
[Project link in Pypi](https://www.pypi.org/project/helloto)

[Project link in Github](https://www.github.io/Lunethra/helloto)
## Usage/Examples

You can use the tool by just giving the name you want to greet.
```bash
helloto Lunethra
```

or say hello in cool ways.
```bash
helloto mybestfriend -m colorful
```
## Support

To resolve issues and make suggestions, please visit the project's GitHub page.


## License

This project uses [MIT License](https://github.com/Lunethra/Helloto/blob/main/LICENSE).
formalpdf 0.1.6
An Apache-licensed package for extracting, creating, filling, and flattening PDF Forms.
Requires Python: >=3.9

# formalpdf

`formalpdf` is an Apache-licensed python library for PDF forms.
It's a unified API for extracting, creating, filling, and flattening forms. 
It has a similar, but _not_ drop-in, high-level API to PyMuPDF.
All of this is possible by wrapping `pdfium`, thanks to the low-level bindings made available through `pypdfium2`.

## Installation

### Using `uv`

```sh
uv pip install formalpdf
```

### Using `pip`

```sh
pip install formalpdf
```

## CLI Usage

🚧 Soon you can use `formalpdf` to fill a PDF from an FDF document using:

```sh
formalpdf fill <input.pdf> <input.fdf> <output.pdf>
```

## Programmatic Usage

### Get All `Widget` Objects in a PDF

```py
import formalpdf

doc = formalpdf.open("path/to/document.pdf") 

for page in doc:
    widgets = page.widgets()
```

A `Widget` object has information about the location, type, and contents of form fields/wdigets in the PDF.
For isntance, a widget might look like:

```py
Widget(
    # name of the widget
    field_name='Text110',
    # label/alternate name, if provided
    field_label='Date (MM/DD/YYYY)',
    # current value (always a string, even if checkbox or combobox)
    field_value='',
    # widget type enum value
    field_type=6,
    # widget type string value 
    field_type_string='Text',
    # widget location Rect
    rect=Rect(
        top=36.95610046386719,
        left=473.5320129394531,
        bottom=24.171100616455078,
        right=587.177978515625
    )
)

```


### Filling out Forms: Updating `Widget` Values

Let's say we had some textbox widget:

```py
w = doc[0].widgets()[0]
```

We can update it with:

```py
w.update("New Value")

doc.save("new_doc.pdf")
```

And when we open `new_doc.pdf` we'll find a the value filled out!

### Creating Forms

🚧 Work in Progress

### Adding Annotations (Highlights, Links, etc.)

🚧 Work in Progress

### Rendering, Extracting Text, Extracting Images

🚧 Work in Progress

### Navigating Unsupported Operations

You can access the raw `PdfDocument` from `pypdfium2` using by calling:

```py
from formalpdf import Document

doc = Document("/path/to/your.pdf")

pdfium_doc = doc.document
```

You can use this to do lower-level operations that aren't yet supported by `formalpdf`.
For instance, if you want to render the first page of the document (currently an unsupported option):

```py
import formalpdf

doc = formalpdf.open("path/to/document.pdf")

pdfium_doc = doc.document
bmp = pdfium_doc[0].render(scale=scale)
pil = bmp.to_pil()
```

## Testing

```
uv run pytest
```

There are a large number of test PDFs found in `tests/data`.


## Roadmap

- [x] create PyPI package
- [x] finish widget extraction 
- [ ] widget updating
  - [x] textbox
  - [ ] checkbox
  - [ ] combobox
- [ ] widget creation
- [x] tests
zenkit 1.3.0.4
Python wrapper for the ZenKit library
Requires Python: >=3.10
Keywords: game, library, game-engine, gothic, gothic2, gothic1, file-formats, file-format-library, zengin

# _ZenKit4Py_


![PyPI - License](https://img.shields.io/pypi/l/zenkit?style=flat&label=License)
![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FGothicKit%2FZenKit4Py%2Fmain%2Fpyproject.toml&style=flat&label=Python)
[![PyPI - Version](https://img.shields.io/pypi/v/zenkit?label=PyPI)](https://pypi.org/project/zenkit/)

A Python-library wrapping the [ZenKit](https://github.com/GothicKit/ZenKit) library for parsing game assets of [PiranhaBytes'](https://www.piranha-bytes.com/) early 2000's games [Gothic](https://en.wikipedia.org/wiki/Gothic_(video_game)) and [Gothic II](https://en.wikipedia.org/wiki/Gothic_II).

> [!TIP]
> See the [documentation](https://zk.gothickit.dev/library/quickstart/#python) for setup instructions.
codetable 1.0.9
Codetable is a lightweight package for seamlessly setting up codes, such as those used in API responses.
Requires Python: >=3.10

```python
from codetable import Code, Codes, CodesStorage, msg

codes_storage = CodesStorage()


class UserErrorCodes(Codes):
    NAMESPACE: str = "user"

    EXPORT_TO: CodesStorage = codes_storage  # For example, export status codes to global storage for use in frontend translations.

    ALREADY_EXISTS: str
    DOES_NOT_EXIST: Code = msg("User does not exist.")


print("# UserErrorCodes.ALREADY_EXISTS\n")
print("code:", UserErrorCodes.ALREADY_EXISTS)

print("\n# UserErrorCodes.DOES_NOT_EXIST\n")
print("obj:", UserErrorCodes.DOES_NOT_EXIST)
print("code:", UserErrorCodes.DOES_NOT_EXIST.code)
print("msg:", UserErrorCodes.DOES_NOT_EXIST.msg)

print("\n# UserErrorCodes.export_codes()\n")
print(UserErrorCodes.export_codes())


class CatCodes(Codes):
    NAMESPACE: str = "cat"

    EXPORT_TO: CodesStorage = codes_storage  # We don't call export_codes here, but it will still be exported due to the presence of EXPORT_TO. export_codes is run automatically when EXPORT_TO is present.

    NOT_HUNGRY: Code = msg("Cat is not hungry!")


print("\n# codes_storage\n")
print(codes_storage)

print("\n# codes_storage.to_json()")
print("# !!! You can change ident by passing an argument !!!\n")
print(codes_storage.to_json())

print("\n# codes_storage.to_dict()\n")
print(codes_storage.to_dict())

# # UserErrorCodes.ALREADY_EXISTS

# code: user_already_exists

# # UserErrorCodes.DOES_NOT_EXIST

# obj: Code(code='user_does_not_exist', msg='User does not exist.')
# code: user_does_not_exist
# msg: User does not exist.

# # UserErrorCodes.export_codes()

# {'user_already_exists': None, 'user_does_not_exist': 'User does not exist.'}

# # codes_storage

# CodesStorage(storage={'user_already_exists': None, 'user_does_not_exist': 'User does not exist.', 'cat_not_hungry': 'Cat is not hungry!'})

# # codes_storage.to_json()
# # !!! You can change ident by passing an argument !!!

# {
#     "user_already_exists": null,
#     "user_does_not_exist": "User does not exist.",
#     "cat_not_hungry": "Cat is not hungry!"
# }

# # codes_storage.to_dict()

# {'user_already_exists': None, 'user_does_not_exist': 'User does not exist.', 'cat_not_hungry': 'Cat is not hungry!'}
```
fast-version 1.4.4
Fastapi versioning package with accept header
Requires Python: <4,>=3.10
Keywords: fastapi, versioning, accept-header

FastAPI versioning library
==
[![Test Coverage](https://codecov.io/gh/community-of-python/fast-version/branch/main/graph/badge.svg)](https://codecov.io/gh/community-of-python/fast-version)
[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
[![Supported versions](https://img.shields.io/pypi/pyversions/fast-version.svg)](https://pypi.python.org/pypi/fast-version)
[![downloads](https://img.shields.io/pypi/dm/fast-version.svg)](https://pypistats.org/packages/fast-version)
[![GitHub stars](https://img.shields.io/github/stars/community-of-python/fast-version)](https://github.com/community-of-python/fast-version/stargazers)

<img src="./logo.svg" width="250" />

This package adds versioning by Accept-header into FastAPI

## Quickstart:

### Installation

```shell
$ pip install fast-version
```

### Defining app and routes
```python
import fastapi

from fast_version import VersionedAPIRouter, init_fastapi_versioning


VERSION_HEADER: str = "application/vnd.some.name+json"
ROUTER_OBJ = VersionedAPIRouter()


@ROUTER_OBJ.get("/test/")
async def test_get() -> dict:
    return {"version": (1, 0)}


@ROUTER_OBJ.get("/test/")
@ROUTER_OBJ.set_api_version((2, 0))
async def test_get_v2() -> dict:
    return {"version": (2, 0)}


app = fastapi.FastAPI()
app.include_router(ROUTER_OBJ)
init_fastapi_versioning(app=app, vendor_media_type=VERSION_HEADER)
```

### Query Examples
```bash
# call 1.0 version
curl -X 'GET' 'https://test.ru/test/' -H 'accept: application/vnd.some.name+json; version=1.0'

curl -X 'GET' 'https://test.ru/test/' -H 'accept: application/vnd.some.name+json'

curl -X 'GET' 'https://test.ru/test/'

# call 2.0 version
curl -X 'GET' 'https://test.ru/test/' -H 'accept: application/vnd.some.name+json; version=2.0'
```
sudoroll 1.0.0
A simple, slightly mean command-line dice roller.
Requires Python: >=3.7

# Sudo Roll 🎲

A simple CLI dice roller that delivers a bash-themed taunt if your roll is less than half the die's value.  
Find it on PyPI: https://pypi.org/project/sudoroll/

![Example usage](img/example.png)

## Installation

```bash
pip install sudoroll
```

## Usage

**Roll a standard 6-sided die:**

```bash
sudoroll
```

**Roll a die with a custom number of sides (e.g., 20-sided):**

```bash
sudoroll --sides 20
```