semvec/pypi-packages huggingface dataset:
ufesp 0.1.1
Série Temporal da Unidade Fiscal do Estado de São Paulo e métodos para recuperar informações da UFESP
Requires Python: >=3.11
Keywords: correção monetária, finance, multas, python, tjsp, ufesp

# Unidade Fiscal do Estado de São Paulo (UFESP)

[![Repo](https://img.shields.io/badge/GitHub-repo-blue?logo=github&logoColor=f5f5f5)](https://github.com/michelmetran/ufesp)
[![Read the Docs](https://img.shields.io/readthedocs/ufesp?logo=ReadTheDocs&label=Read%20The%20Docs)](https://ufesp.readthedocs.io/)<br>
[![Publish Python to PyPI](https://github.com/michelmetran/ufesp/actions/workflows/publish-to-pypi-uv.yml/badge.svg)](https://github.com/michelmetran/ufesp/actions/workflows/publish-to-pypi-uv.yml)
[![PyPI](https://img.shields.io/pypi/v/ufesp?logo=pypi&label=PyPI&color=blue)](https://pypi.org/project/ufesp/)
[![PyPI Test](https://img.shields.io/pypi/v/ufesp?logo=pypi&server=test&label=PyPI%20Test&color=orange)](https://test.pypi.org/project/ufesp/)

A Unidade Fiscal do Estado de São Paulo (UFESP) é utilizada, dentre outras funções, para calcular as multas ambientais do estado de São Paulo. É definida pela Secretaria da Fazenda do Estado de São Paulo ([SEFAZ](https://portal.fazenda.sp.gov.br/)).

Com objetivo de obter os dados, para cálculos de multas, optei por utilizar o [_site_ oficial](https://legislacao.fazenda.sp.gov.br/Paginas/ValoresDaUFESP.aspx) da SEFAZ com as informações. Fiz a partir de 1997 apenas.

O repositório [ufesp](https://github.com/michelmetran/ufesp) objetivou disponibilizar os valores de UFESP de maneira facilitada, por meio de um servidor, com atualização periódica.

![Photo by [**StellrWeb**](https://unsplash.com/photos/djb1whucfBY) on [Unsplash](https://unsplash.com)](./docs/assets/stellrweb2.jpg)

<br>

---

## Como Instalar?

```python
# Instala
!pip3 install ufesp --upgrade
```

<br>

---

## Como Usar?

Para testar fiz um [Google Colab](https://colab.research.google.com/drive/1NwV9mGUlPOlYFcZ6-ieEXL4HVPShO928?usp=sharing).

Toda a documentação encontra-se em [ufesp.readthedocs.io](https://ufesp.readthedocs.io/).

```python
import ufesp

# Pega UFESP para um dado dia
ufesp.get_ufesp_from_date(date='2025-04-02')

# Pega UFESP para um dado ano
dados = ufesp.get_ufesp_from_year(year=2024)
```

<br>

Outros métodos (que poderiam ser privados).

```python
# Pega Tabela Inteira
ufesp.get_table()

# Atualiza Tabela
ufesp.update_table()
```

<br>

A partir da versão 0.0.16, com contribuição de [ubalklen](https://github.com/ubalklen), o pacote busca os dados mais recentes do _site_ da SEFAZ-SP automaticamente.
abhedya 1.0.40
Sanskrit-Encoded Post-Quantum Cryptography SDK
Requires Python: >=3.7

# Abhedya: Sanskrit-Encoded Post-Quantum Cryptography

**Unmatched Speed. Unbreakable Security.**

Abhedya is a high-performance Post-Quantum Cryptography (PQC) library that implements a Lattice-based (LWE) cryptosystem with a unique capability: **Linguistic Steganography**. It can encode ciphertexts into valid, prosodically correct Sanskrit verse.

## Features

- **Post-Quantum Security**: Based on the Learning With Errors (LWE) problem ($N=768, Q=3329$).
- **Sanskrit Steganography**: "Metered Mode" produces ciphertexts that follow classical **Anushtubh** meter (Sloka).
- **High Performance**: Sub-microsecond encryption (<1ms) via optimized Rust core.
- **Cross-Platform**: Python bindings for the core Rust implementation.

## Installation

```bash
pip install abhedya
```

_Note: This package requires a compatible C runtime (provided in wheels for Linux/macOS/Windows)._

## Quick Start

```python
from abhedya import Abhedya, EncryptionMode

# Initialize
crypto = Abhedya()

# 1. Generate Keys (Kyber-style LWE)
pk, sk = crypto.keygen()
print(f"Public Key Size: {len(pk)} bytes")

# 2. Encrypt (Standard Mode - High Speed)
message = b"Secret Message"
ciphertext = crypto.encrypt(pk, message, mode=EncryptionMode.STANDARD)
print(f"Ciphertext: {len(ciphertext)} bytes")

# 3. Decrypt
decrypted = crypto.decrypt(sk, ciphertext)
print(f"Decrypted: {decrypted.decode('utf-8')}")
```

## Advanced Usage: Metered Mode (Steganography)

To generate ciphertext that mimics the statistical properties of Sanskrit verse (Poetry), use `EncryptionMode.METERED`.

```python
# Encrypt with Metering (Slower, but steganographic)
ciphertext_verse = crypto.encrypt(pk, message, mode=EncryptionMode.METERED)

# The output binary is shaped to map to Sanskrit syllables
# adhering to Laghu/Guru (Light/Heavy) weight patterns.
```

## API Reference

### `Abhedya(lib_path: str = None)`

Initializes the library. Automatically finds the shared object if installed via pip.

### `keygen() -> (bytes, bytes)`

Generates a new Keypair.

- Returns: `(public_key, secret_key)`

### `encrypt(pk: bytes, msg: bytes, mode: int) -> bytes`

Encrypts a message.

- `mode`:
  - `0` (Standard): Raw LWE output.
  - `1` (Metered): Prosody-compliant output.

### `decrypt(sk: bytes, ct: bytes) -> bytes`

Decrypts the ciphertext.

## License

MIT License. See [Repository](https://github.com/ParamTatva-org/abhedyam) for details.
red-reddit-cli 0.2.1
Red - a Reddit CLI
Requires Python: >=3.13

# Red - a Reddit CLI (under construction)

Uses [PRAW](https://praw.readthedocs.io/en/stable/index.html), so need to [set up configuration according to the docs](https://praw.readthedocs.io/en/stable/getting_started/configuration.html)

- Lists all subscribed subs via

  ```bash
  $ red subs ls
  ```

- And declaratively manages Multireddits (custom feeds):
  - Generate existing custom feeds YAML:
    ```bash
    $ red multis genconf
    wrote /Users/george/.config/red.yaml
    ```

- Edit YAML

- Apply updates:

  ```bash
  $ red multis apply
  ```

  With this command the YAML file is the source of truth:
  - If a multireddit doesn't exist, create it and add subs declared under it
    - subscribe to subs too

  - If a multireddit exists online but not in the file, delete it
    - member subs stay subscribed

  - If a multireddit exists, update it with subs declared under in the file

# License

[MIT](LICENSE)

# Copyright

2025 George Kontridze
dbt-metamodels 0.1.0
Define your dbt models in yaml
Requires Python: >=3.8
Keywords: dbt, models, yaml

# dbt-metamodels

Define your dbt models in YAML using metamodels - a powerful way to generate SQL models from macro calls defined in your schema files.

## Overview

`dbt-metamodels` extends dbt to allow you to define models directly in your `schema.yml` files using a `metamodel` field. Instead of writing separate SQL files, you can reference macros that generate your SQL code, making your dbt project more maintainable and DRY.

## Installation

```bash
pip install dbt-metamodels
```

Or using `uv`:

```bash
uv add dbt-metamodels
```

## Usage

### 1. Define a Macro

First, create a macro that generates your SQL. For example, in `macros/demo_model.sql`:

```sql
{% macro demo_model(v) %}
select {{ v }} as id
{% endmacro %}
```

### 2. Define Models in schema.yml

Instead of creating separate `.sql` files, define your models in `schema.yml` using the `metamodel` field:

```yaml
version: 2

models:
  - name: my_first_dbt_model
    description: "A starter dbt model"
    metamodel: demo_model(1)
    columns:
      - name: id
        description: "The primary key for this table"

  - name: my_second_dbt_model
    description: "A starter dbt model"
    metamodel: demo_model(2)
    columns:
      - name: id
        description: "The primary key for this table"
```

### 3. Use Metamodels Alongside Regular Models

You can mix metamodels with regular SQL models. For example, `my_final_dbt_model.sql` can reference metamodel-generated models:

```sql
{{ config(materialized='table') }}

with source_data as (

    select * from {{ ref('my_first_dbt_model') }}
    union all
    select * from {{ ref('my_second_dbt_model') }}

)

select * from source_data
```

## How It Works

When dbt reads your project files:

1. The plugin intercepts the file reading process
2. It scans `schema.yml` files for models with a `metamodel` field
3. For each metamodel definition, it automatically generates a corresponding `.sql` file
4. The generated SQL wraps your macro call in `{{ }}` syntax
5. dbt then processes these generated files as if they were regular SQL models

## Example Project Structure

```
metamodels_demo/
├── dbt_project.yml
├── macros/
│   └── demo_model.sql          # Macro definition
├── models/
│   └── example/
│       ├── schema.yml          # Model definitions with metamodels
│       └── my_final_dbt_model.sql  # Regular SQL model
└── profiles.yml
```

## Benefits

- **DRY Principle**: Reuse macro logic across multiple models
- **YAML-First**: Define models alongside their documentation
- **Flexibility**: Mix metamodels with regular SQL models
- **Maintainability**: Update model logic in one place (the macro)

## Requirements

- Python >= 3.8
- dbt-core >= 1.5.0

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Links

- [Homepage](https://github.com/klyusba/dbt-metamodels)
- [Repository](https://github.com/klyusba/dbt-metamodels.git)
- [Issues](https://github.com/klyusba/dbt-metamodels/issues)