semvec/pypi-packages huggingface dataset:
registry_downloader 0.1.5
Download & analyze business registry data
Requires Python: >=3.12
Keywords: business data, downloader, registry

# Business Registry Download

This is a tool to download business registry data from Estonian, Finnish, Latvian, Lithuanian and Czech business registers. These files are usually updated daily by the registers and contain information about companies, their officers, and other relevant information.

Happy to take PRs for other countries!

It's easy to load these files with [dlt](https://dlthub.com/), [duckdb](https://duckdb.org/) or transform them with [dbt](https://www.getdbt.com/) and integrate this into your data pipelines.

The downloads are all done in parrallel and async so it's pretty fast.

## To use from command line

Make sure you have uv installed
```sh
curl -LsSf https://astral.sh/uv/install.sh | sh
```

_Run with default settings:_
```sh
uvx registry_downloader
```

_Or override options for download directory, countries, and override URL:_
```sh
uvx registry_downloader --download-dir "./downloads" --countries ee --override-url ee=https://avaandmed.ariregister.rik.ee/et/avaandmete-allalaadimine
```

## To use as a library

You can install the `registry_downloader` package using either `pip` or `uv`. Here are examples for both:

**Using pip:**
```sh
pip install registry_downloader
```

**Using uv:**
```sh
uv add registry_downloader
```

_Run with default settings:_
```python
import asyncio
from registry_downloader import run_downloader

async def main() -> None:
    await run_downloader()

if __name__ == "__main__":
    asyncio.run(main()) 
```

_Or override options for download directory, countries, and override URL:_
```python
import asyncio
from registry_downloader import run_downloader

async def main() -> None:
    await run_downloader(
        download_dir="./downloads",
        countries=["ee"],
        override_url=["ee=https://avaandmed.ariregister.rik.ee/et/avaandmete-allalaadimine"]
    )

if __name__ == "__main__":
    asyncio.run(main()) 
```

## To develop

1. Install uv
```sh
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Create a virtual environment and activate it
```sh
uv venv && source .venv/bin/activate
```

3. Install dependencies and ensure the virtual environment is in sync
```sh
uv sync
```

4. Build the project or run it locally with defaults
```sh
uv build
```
_or_
```sh
uv run src/registry_downloader
```
sympla_tools 0.1.6
SDK para integração com a API da Sympla
Requires Python: ==3.10.14

# SymplaTools SDK

SymplaTools é um SDK para integração com a plataforma Sympla, atualmente incluindo funcionalidades como:

* Validação de QR codes assinados com ECDSA.

---

# Pypi

Este projeto está em um repositório público, e tem como objetivo facilitar o uso das funcionalidades da Sympla.

https://pypi.org/project/sympla_tools/

###  Também disponível no package registry do gitlab

https://gitlab.com/symplax/sympla-tools/-/packages

---

## Instalação

Para instalar as dependências, use [Poetry](https://python-poetry.org/):

```bash
### Pypy
poetry add sympla-tools


### Package registry Gitlab
poetry add git+ssh://git@gitlab.com:gitlab.com/symplax/sympla-tools/-/packages#0.1.5
```

## Configuração

Para validar a assinatura, é necessário definir o endereço Ethereum conhecido (`KNOWN_ETHEREUM_ADDRESS`) como uma variável de ambiente. Este será o endereço usado para verificar a autenticidade da assinatura do QR code.

Configure o endereço Ethereum conhecido com o seguinte comando:

```bash
export KNOWN_ETHEREUM_ADDRESS="0x0ff5a47F678e1E490b9c467631Ab84Dc1665a7eA"
```

## Uso

Após configurar o endereço Ethereum, você pode usar o SDK para validar a assinatura de um QR code Ethereum.

### Exemplo de uso via linha de comando

Para validar uma assinatura via linha de comando, execute:

```bash
python -m sympla_tools.tickets.validate "ASSINATURA"
```

Substitua `"ASSINATURA"` pela assinatura que deseja validar. O SDK verificará se a assinatura corresponde ao endereço Ethereum configurado.

### Funções Principais

- **validate**: Função principal para validar uma assinatura Ethereum. A função compara a assinatura com o endereço configurado e retorna se a assinatura é válida.
declarativeenum 1.0.0
A declarative and flexible approach to Python enums with preprocessing, validation, and more
Requires Python: >=3.7
Keywords: declarative, enum, preprocessing, validation

# DeclarativeEnum

A declarative and flexible approach to Python enums that supports preprocessing, validation, namespacing, and direct value access.

## Features

- Value preprocessing and validation
- Auto-numbering support
- Namespace prefixing
- Pattern formatting
- Value type enforcement
- Method chaining with direct access
- Aliases support

## Installation

```bash
pip install declarativeenum
```

## Basic Usage

```python
from declarativeenum import DeclarativeEnum

# Basic enum with direct string values
class Colors(DeclarativeEnum):
    RED
    BLUE
    GREEN

assert Colors.RED.value == "RED"

# Enum with preprocessing
class Headers(DeclarativeEnum):
    __preprocess__ = lambda x: f"X-Custom-{x.lower()}"
    TRACKING
    VERSION

assert Headers.TRACKING.value == "X-Custom-tracking"

# Enum with type conversion and validation
class Ports(DeclarativeEnum):
    __type__ = int
    __validate__ = lambda x: 0 <= x <= 65535
    HTTP = "80"
    HTTPS = "443"

assert isinstance(Ports.HTTP.value, int)
assert Ports.HTTPS.value == 443

# Enum with direct value access
class StatusCode(DeclarativeEnum):
    __directaccess__ = True
    OK = 200
    NOT_FOUND = 404

# Direct comparison works
assert StatusCode.OK == 200
```

## Advanced Features

### Preprocessing and Validation

```python
class ValidatedEnum(DeclarativeEnum):
    __preprocess__ = lambda x: x.upper()
    __validate__ = lambda x: len(x) <= 10
    __type__ = str

    SHORT
    ALSO_SHORT
```

### Pattern Formatting

```python
class APIEndpoints(DeclarativeEnum):
    __pattern__ = "/api/v1/{}"
    __namespace__ = "users"

    PROFILE  # becomes "/api/v1/users/profile"
    SETTINGS # becomes "/api/v1/users/settings"
```

### Auto-numbering

```python
class OrderedEnum(DeclarativeEnum):
    __autonumber__ = 100  # Start from 100
    FIRST   # 100
    SECOND  # 101
    THIRD   # 102
```

### Method Chaining with Direct Access

```python
class Headers(DeclarativeEnum):
    __directaccess__ = True
    CONTENT_TYPE = "application/json"

assert Headers.CONTENT_TYPE.upper() == "APPLICATION/JSON"
```

## License

MIT License - see LICENSE file for details.