semvec/pypi-packages huggingface dataset:
cronygen 0.1.0
Official Python SDK for CronyGen Text-to-Speech API
Requires Python: >=3.8
Keywords: ai, audio, speech-synthesis, text-to-speech, tts, voice

# CronyGen Python SDK

Official Python SDK for the CronyGen Text-to-Speech API.

## Installation

```bash
pip install cronygen
```

## Quick Start

```python
from cronygen import CronyGen

# Initialize client
client = CronyGen(api_key="crony_sk_your_api_key")

# Generate TTS with a default voice
generation = client.tts.generate(
    text="Hello world! This is a test of CronyGen text-to-speech.",
    voice="en-us-aria"
)

# Download the audio
client.tts.download(generation, "output.wav")
print(f"Audio saved! Duration: {generation.output_duration_seconds}s")
```

## Features

- **Sync & Async clients** - Use `CronyGen` or `AsyncCronyGen`
- **Default voices** - 20+ pre-configured voices across accents
- **Automatic polling** - Wait for generation completion
- **Type hints** - Full type annotations for IDE support

## Voices

```python
# List default voices
voices = client.voices.list_defaults(gender="female", accent="american")
for voice in voices:
    print(f"{voice.name}: {voice.slug}")

# List your cloned voices (created via dashboard)
my_voices = client.voices.list()
for voice in my_voices.data:
    print(f"{voice.name}: {voice.id} ({voice.status})")

# Use a cloned voice for TTS
generation = client.tts.generate(
    text="This is my cloned voice!",
    voice=my_voices.data[0].id,
    voice_type="cloned"
)
```

## Async Usage

```python
import asyncio
from cronygen import AsyncCronyGen

async def main():
    async with AsyncCronyGen(api_key="crony_sk_your_api_key") as client:
        generation = await client.tts.generate(
            text="Hello async world!",
            voice="en-uk-ronald"
        )
        print(f"Audio URL: {generation.output_audio_url}")

asyncio.run(main())
```

## Error Handling

```python
from cronygen import CronyGen, InsufficientCreditsError, RateLimitError

client = CronyGen(api_key="crony_sk_your_api_key")

try:
    generation = client.tts.generate(text="Hello world!")
except InsufficientCreditsError as e:
    print(f"Not enough credits: {e.available} available, {e.required} required")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
```

## Documentation

Full documentation at [zingotron.com/docs/sdks/python](https://zingotron.com/docs/sdks/python)
totvs-dta-utils 1.4.15
Lib for integration with DTA services
Requires Python: >=3.10

# Dta Utils 🧰 🛠️
**Agilize a integração entre serviços DTA**


### O que são Serviços DTA?

Uma coleção de serviços para facilitar e acelerar o desenvolvimento e monitoramento de Aplicações, com foco em aplicativos de IA generativa.


## Introdução

Esse pacote possui módulos extras que auxiliam o desenvolvimento de integrações com os serviços do DTA.

## Extra "Secrets"

### Instalação

Instale o módulo `secrets` com:
```shell
pip install "totvs-dta-utils[secrets]"
```

Ou utilizando `poetry`:
```shell
poetry add "totvs-dta-utils[secrets]"
```

### Configuração inicial:

Adicione as seguintes variaveis no `.env` do seu projeto:
```env
DTA_ENVIRONMENT="development"
DTA_INTEGRATION_URL="{DTA_INTEGRATION_URL}"
```
> NOTE: Para ambiente em cloud, onde terá acesso irrestrito aos secrets, o valor do `DTA_ENVIRONMENT`deve ser `production`.

### Utilização

```python
from dta_utils_python import DtaSecrets

auth = DTA_JWT  # CLIENT AUTHORIZATION

secrets = DtaSecrets(authorization=auth,
                     project="dta-empodera")

all_secrets = secrets.all()  # Get the latest version of all secrets
my_secret = secrets.get("MY_SECRET")  # Get the latest version of a secret
my_secret_v2 = secrets.get("MY_SECRET", version=2)  # Get a specific version of a secret
```
> Observação: Para ambiente em nuvem na rede DTA, nenhuma autenticação é necessária.

> Observação 2: Ainda em ambientes de nuvem, usando Cloud Run, lembrar de habilitar TODAS as chamadas de saída do serviço DEVEM passar pela VPC. Selecione `Route all traffic to the VPC` na configuração de Rede do serviço Cloud Run

### Demais configurações:
```python
DtaSecrets(
    authorization=auth,
    project="dta-empodera",
    raise_exception: bool = True,  # Default "False" - Levanta exceção em caso de erro ao obter a secret
    autoload: bool = False,  # Default "True" - Pré-carrega todas as secrets do projeto na inicialização da classe e as mantém em cache de memória
)
```

### Tipos de retorno:
- `.get("SECRET_2")`:
Retorna o valor da secret ou `None` caso a secret não exista.
```python
any: "321654"
```

- `.all()`:
Retorna um dicionário (hashmap) contendo a última versão de todas as secrets
```python
dict: {
    "SECRET_1": "123456",
    "SECRET_2": "321654",
    "SECRET_3": "My secret",
}
```
quvac 0.1.3
Calculate quantum vacuum signal from the interaction of electromagnetic fields.
Requires Python: >=3.12
Keywords: quantum, vacuum, qed, maxwell, electrodynamics

# quvac

![Tests](https://github.com/maxbalrog/quantum-vacuum/actions/workflows/tests.yml/badge.svg)
![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/maxbalrog/d6b0645fa035119a53bb6356d169c98b/raw/quvac_coverage_badge.json)

<img src="images/logo.jpg" alt="Alt Text" width="250" height="230">

Quvac (from quantum vacuum, pronounced as qu-ack 🐸) allows to calculate quantum vacuum signals produced during light-by-light scattering.

Documentation is available [here](https://maxbalrog.github.io/quvac/).

> [!IMPORTANT]
> This project is still in development!

## Installation

It is recommended to create a separate Python environment for this package, e.g.

```bash
micromamba create -n quvac python=3.12
```

After cloning the git repository and entering it, choose relevant optional dependencies

- `[test]` allows to run tests
- `[plot]` installs `matplotlib` and `jupyterlab`
- `[docs]` installs `sphinx` and everything necessary for documentation generation
- `[optimization]` installs Bayesian optimization package
- `[light]` is a shorthand for `[test,plot,docs]`

To install all dependencies, run

```bash
pip install .[all]
```

> [!NOTE]
> For example, if you do not require optimization capabilities, run
> 
> ```bash
> pip install .[test,plot]
> ```

After successfull installation with `[all]` or `[test]` option, run ``pytest`` to make sure the installation was
successfull (it takes some time).

```bash
pytest
```

### Using `uv`

If you prefer using `uv` package manager then the installation follows similar steps. After cloning the git repository and entering 
it, create the environment and install `quvac`

```bash
uv venv
uv pip install .[light]
```

You can test the installation with

```bash
uv run pytest
```

Launch the jupyterlab (e.g. tutorial notebooks) with

```bash
uv run jupyter lab
```

Generate the documentation with

```bash
uv run python -m sphinx -b html docs/source docs/build/html
```

## Contribution

If you noticed a bug or have a feature request, open a new [issue](https://github.com/maxbalrog/quvac/issues).

## Acknowledgements

If you use this code and/or consider it useful, please cite our article.

```bibtex
@article{valialshchikov2025back,
  title={Back-reflection in dipole fields and beyond},
  author={Valialshchikov, Maksim and Karbstein, Felix and Seipt, Daniel and Zepf, Matt},
  journal={arXiv preprint arXiv:2510.11764},
  year={2025}
}
```

## References

[1] - F. Karbstein, and R. Shaisultanov. "Stimulated photon emission from the vacuum." PRD 91.11 (2015): 113002 [[article]](https://arxiv.org/abs/1412.6050).

[2] - A. Blinne, et al. "All-optical signatures of quantum vacuum nonlinearities in generic laser fields." PRD 99.1 (2019): 016006 [[article]](https://arxiv.org/abs/1811.08895).
licomp-doubleopen 0.1.5
Simple command line tool to check compatibility between two licenses, given context 
Requires Python: >=3.6

# licomp-doubleopen (Licomp DoubleOpen)

Licomp implementation of Double Open Project's license classifications

Licomp DoubleOpen provides compatibility data:

* between an Open Source outbound license and inbound Open Source licenses
* when distributing a binary, linking to (e.g. linking to a library) Open Source components
* the Open Source components are unmodified

Licomp DoubleOpen uses Open Source License Compliance Handbook by The Fintech Open Source Foundation (www.finos.org).

## Introduction 

Licomp DoubleOpen implements the [Licomp](https://github.com/hesa/licomp) api for communication with the Licomp resources. For a better understanding of Licomp we suggest you read:

* [Licomp basic concepts](https://github.com/hesa/licomp/#licomp-concepts)
* [Licomp reply format](https://github.com/hesa/licomp/blob/main/docs/reply-format.md)

The various licomp resources below can be accessed as a group by:
* [licomp-toolkit](https://github.com/hesa/licomp-toolkit) - (`pip install licomp-toolkit`)

Licomp is used be the following compatibility resources:
* [licomp-hermione](https://github.com/hesa/licomp-hermione) - (`pip install licomp-hermione`)
* [licomp-proprietary](https://github.com/hesa/licomp-proprietary) - (`pip install licomp-proprietary`)
* [licomp-reclicense](https://github.com/hesa/licomp-reclicense) - (`pip install licomp-reclicense`)
* [licomp-dwheeler](https://github.com/hesa/licomp-dwheeler) - (`pip install licomp-dwheeler`)
* [licomp-osadl](https://github.com/hesa/licomp-osadl) - (`pip install licomp-osadl`)

# Using Licomp DoubleOpen

Since Licomp DoubleOpen implements [Licomp](https://github.com/hesa/licomp) we refer to the Licomp guides (both cli and python api).

## Command line interface

See [Licomp Comand Line Interface](https://github.com/hesa/licomp/blob/main/docs/cli-guide.md)

_Note: the commmad line program for Licomp DoubleOpen is called `licomp-doubleopen`._

## Python module

See [Licomp Python API](https://github.com/hesa/licomp/blob/main/docs/python-api.md)

# Installing Licomp DoubleOpen

## From pypi.org

Licomp DoubleOpen is available via [pypi.org](https://pypi.org/) at: [https://pypi.org/project/licomp-doubleopen/](https://pypi.org/project/licomp-doubleopen/).


To install, simply do the following:

```
$ pip install licomp-doubleopen
```

## From github

Installing from github assumes you already have `pip` installed.

```
$ git clone https://github.com/hesa/licomp-doubleopen
$ pip install -r requirements.txt
$ pip install -r requirements-dev.txt
$ pip install .
```
pysorteddict 0.13.1
Python dictionary in which the keys are always in ascending order
Requires Python: >=3.10
Keywords: sorted, dictionary, map, RB Tree, cross-platform

# pysorteddict

Enriches Python with `SortedDict`, a sorted dictionary: a dictionary in which the keys are always in ascending order.

[Read more on the website.](https://tfpf.github.io/pysorteddict/)

[View the project on PyPI.](https://pypi.org/project/pysorteddict/)

[Explore the repository on GitHub.](https://github.com/tfpf/pysorteddict)

[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
[![ci](https://github.com/tfpf/pysorteddict/actions/workflows/ci.yml/badge.svg)](https://github.com/tfpf/pysorteddict/actions/workflows/ci.yml)
[![pages](https://github.com/tfpf/pysorteddict/actions/workflows/pages.yml/badge.svg)](https://github.com/tfpf/pysorteddict/actions/workflows/pages.yml)
[![coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fgist.github.com%2Ftfpf%2F20ce6b322e80fe740f1ba6365fe7f110%2Fraw%2Fcoverage.json&query=%24.line_percent&suffix=%25&style=flat&logo=shieldsdotio&label=coverage&color=%2327B4A6)](https://gist.github.com/tfpf/20ce6b322e80fe740f1ba6365fe7f110/raw/coverage.json)

<p align="center">
 <img src="https://github.com/user-attachments/assets/e9d1e78e-c0fd-4d87-93f6-e293ddef31ba" />
</p>