semvec/pypi-packages huggingface dataset:
hoax-hoa-executor 0.1.6
Execute HOA omega-automata
Requires Python: <3.15,>=3.12

## HOAX: Hanoi Omega-Automata eXecutor

This tool executes one or more automata expressed in HOA format.
Execution may be customised in several ways by means of config files.

You can obtain it from `pip`:

```sh
pip install hoax-hoa-executor
```

If you only need the command-line tool, we recommend using `pipx` or `uv`:

```sh
pipx install hoax-hoa-executor  # or
uv tool install hoax-hoa-executor
```

## Running from sources (developers)

The tool requires Python >= 3.12 and [`uv`](https://docs.astral.sh/uv/).

After cloning this repository:

```
cd hoax
# Run
uv run hoax examples/nondet.hoa --config examples/flip.toml
```

Use Ctrl-C to stop. Use

```
uv run hoax --help
```

For usage instructions.

## Publications 

If you use `hoax` in an academic project, please cite this paper:

```
@inproceedings{distefano2025executionmonitoringhoaautomata,
    title={Execution and monitoring of {HOA} automata with {HOAX}}, 
    author={Di Stefano, Luca},
    year={2025},
    booktitle={25th International Conference on Runtime Verification ({RV})}
    url={https://arxiv.org/abs/2507.11126},
    pubstate={To appear}
}
```
django-genfkadmin 0.1.4
No frills GenericForeignKeys for your Django Admin
Requires Python: <3.14,>=3.10

# Django GenericFKAdmin

Using `GenericForeignKey` in your Django models is cool, the default behavior of
Django Admin is not. This package allows you to replace the `content_type` and
`object_id` fields in your admin forms with a single input that is prefilled
with only the models related through `GenericRelation` fields.

## Setup

### Install

```shell
pip install django-genfkadmin
````

```shell
uv add django-genfkadmin
```

### Usage

Using this package is pretty simple.

1. Create a subclass of `GenericFKModelForm` for your model.
2. Create a subclass of `GenericFKAdmin` for your model.
3. ???
4. Profit!

e.g. in your `admin.py`
```python
from genfkadmin.admin import GenericFKAdmin
from genfkadmin.forms import GenericFKModelForm


class PetAdminForm(GenericFKModelForm):

    class Meta:
        model = Pet
        fields = "__all__"


@admin.register(Pet)
class PetAdmin(GenericFKAdmin):
    form = PetAdminForm
```

![example](docs/screenshots/example_base_admin.png)

#### Providing a `filter_callback`
If you want to further filter the queryset (perhaps by something related to
the parent instance of your model with `GenericForeignKey`) you can pass a
`partial` with a keyword argument of `filter_callback` as follows.

```python
@admin.register(MarketingMaterial)
class MarketingMaterialAdmin(GenericFKAdmin):
    form = MarketingMaterialAdminForm

    def get_form(self, request, obj=None, change=False, **kwargs):
        if obj:
            self.form = partial(
                MarketingMaterialAdminForm,
                filter_callback=lambda queryset: queryset.filter(customer=obj.customer),
            )
        else:
            # this is important, otherwise, 1. add -> 2. change -> 3. add
            # will use the filter on 2. in 3.
            self.form = MarketingMaterialAdmin
        return super().get_form(request, obj=obj, change=change, **kwargs)
```

Now when loading an existing `MarketingMaterial`, the `content_object` options are filtered by the chosen `Customer`
![example](docs/screenshots/example_filter_admin.png)

A complete example django app exists in this repository at [here](/example)
django-dict-field 0.1.0a1
Django extension for efficient and easy storing dict data in django field.
Requires Python: >=3.10

# django-dict-field

[![PyPI version](https://img.shields.io/pypi/v/django-dict-field.svg)](https://pypi.org/project/django-dict-field/)
[![Python Version](https://img.shields.io/pypi/pyversions/django-dict-field.svg)](https://pypi.org/project/django-dict-field/)
[![PyPI license](https://img.shields.io/pypi/l/django-dict-field.svg)](https://pypi.python.org/pypi/django-dict-field/)
[![test](https://github.com/skv0zsneg/django-dict-field/actions/workflows/test.yml/badge.svg?event=push)](https://github.com/skv0zsneg/django-dict-field/actions/workflows/test.yml)
[![typing & lint](https://github.com/skv0zsneg/django-dict-field/actions/workflows/typing_and_lint.yml/badge.svg?event=push)](https://github.com/skv0zsneg/django-dict-field/actions/workflows/typing_and_lint.yml)

> ⚠️ This project under active developing.

Django extension for storing dict data in relation database field with fast performance and flex schema.

## 📍 Purpose

Sometimes we need to store some key value data in storages. Often it also need to be efficient for work with big data and have some validation and another features.

`django-dict-field` is a tool build around amazing [msgspec](https://github.com/jcrist/msgspec) serialization and validation library for solving this problems like a charm ✨

**DictField vs JSONField Benchmark**

Operations on 100 000 size dict on PostgreSQL DB. Script [here](/benchmarks/jsonfield_benchmark.py).

![DictField vs JSONField Benchmark](docs/media/bechmark.png)


## 🚀 Quick start

1. Install `django-dict-field`.

```
pip install django-dict-field
```

2. Add `DictField` to your model.

```python
from django.db.models import Model, CharField, DateTimeField
from django_dict_field import DictField

class Car(Model):
    model = CharField()
    creation_data = DateTimeField()
    configuration = DictField()  # for storing a lot of configuration settings
```

3. Work with it!

```python
# create
car = Car.objects.create(
    model="Toyota Camry",
    creation_data=datetime(2021, 3, 15),
    configuration={
        "capacity": 2.5,
        "drive": "FWD",
        "consumption": 6.8,
    }
)

# read
assert car.configuration["drive"] == "FWD"

# update
car.configuration["capacity"] = 2.8

# delete
del car.configuration["doors"]
```

## 🤗 Author

Made with love by [@skv0zsneg](https://github.com/skv0zsneg)
cognito-jwt-verifier 0.0.4
A utility for verifying JWTs issued by AWS Cognito.
Requires Python: >=3.12

# cognito-jwt-verifier

A utility for verifying JWTs issued by AWS Cognito.

## ✨ Features

- **Async & non‑blocking** verification using `aiohttp`.
- Automatic **JWKS caching & key rollover**.
- Validates both **ID** and **access** tokens out‑of‑the‑box.
- Zero heavy dependencies (only `aiohttp`, `PyJWT`, `cryptography`).

## 📦 Installation

```bash
pip install cognito-jwt-verifier
```

## 🚀 Quick Start

```python
import asyncio
from cognito_jwt_verifier import AsyncCognitoJwtVerifier

async def main():
    verifier = AsyncCognitoJwtVerifier(
        issuer="https://cognito-idp.us-east-2.amazonaws.com/<USER_POOL_ID>",
        client_ids=["<APP_CLIENT_ID>"],
    )

    await verifier.init_keys()  # optional warm‑up

    claims = await verifier.verify_id_token("<ID_TOKEN>")
    print(claims)

asyncio.run(main())
```

## 🛡️ FastAPI example

```python
from contextlib import asynccontextmanager

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2AuthorizationCodeBearer
from jwt import PyJWTError

from cognito_jwt_verifier import AsyncCognitoJwtVerifier

ISSUER = "https://cognito-idp.us-east-2.amazonaws.com/us-east-2_ae7uogn5r"
CLIENT_IDS = ["4pvqqexampleclientid"]

verifier = AsyncCognitoJwtVerifier(ISSUER, client_ids=CLIENT_IDS)

oauth2_scheme = OAuth2AuthorizationCodeBearer(
    authorizationUrl=f"{ISSUER}/oauth2/authorize",
    tokenUrl=f"{ISSUER}/oauth2/token",
)

@asynccontextmanager
async def lifespan(app: FastAPI):
    await verifier.init_keys()
    try:
        yield
    finally:
        await verifier.close()

app = FastAPI(lifespan=lifespan)

async def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        return await verifier.verify_access_token(token)
    except Exception as exc:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=str(exc),
            headers={"WWW-Authenticate": "Bearer"},
        )

@app.get("/user")
async def read_user(user: dict = Depends(get_current_user)):
    return {"user": user}
```

## 📚 API at a glance

| Method | Description |
|--------|-------------|
| `init_keys()` | Prefetch JWKS (optional). |
| `verify_id_token(token: str)` | Validate an *ID* token & return claims. |
| `verify_access_token(token: str)` | Validate an *access* token & return claims. |
| `close()` | Close the internal `aiohttp` session. |

> If Cognito rotates its keys, the verifier fetches the new JWKS automatically.