semvec/pypi-packages huggingface dataset:
jaseci 2.2.17
Jaseci - A complete AI-native programming ecosystem with Jac language, LLM integration, and full-stack web apps
Requires Python: >=3.11
Keywords: jac, jaclang, jaseci, ai, llm, full-stack, web-apps, jac-client, jac-scale, programming-language, machine-learning, artificial-intelligence

# Jaseci

### Complete AI-Native Programming Ecosystem

Jaseci is a **meta-package** that provides a unified installation for the complete Jaseci ecosystem.

## What's Included

When you install `jaseci`, you automatically get:

- **jaclang** - The Jac programming language
- **byllm** - LLM integration for AI-native programming
- **jac-client** - Full-stack web applications with React-like components in Jac

## Installation

```bash
pip install jaseci
```

## Quick Start

After installation, you can start using Jac:

```bash
jac --help
```

## Documentation

- **Jac Language**: [https://www.jac-lang.org](https://www.jac-lang.org)
- **byLLM (AI Integration)**: [https://www.byllm.ai](https://www.byllm.ai)
- **Jac Client**: [https://docs.jaseci.org/jac-client/](https://docs.jaseci.org/jac-client/)
- **Jaseci Homepage**: [https://jaseci.org](https://jaseci.org)
- **GitHub Repository**: [https://github.com/Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci)
pisek 2.3.0
Tool for developing tasks for programming competitions.
Requires Python: >=3.12

# Pisek ⏳

Tool for developing tasks for programming competitions.

## Installation

Pisek requires Python 3.12 or newer. You can install it with pip:
```bash
pip install pisek
```

## Usage

You can create a task skeleton with:
```bash
pisek init
```

Test the task in the current directory with: 
```bash
pisek test
```

## Docs

See our [user documentation](https://piskoviste.github.io/pisek/) for more details.
protoc-gen-validate 1.3.3
PGV for python via just-in-time code generation
Requires Python: >=3.10

# Protoc-gen-validate (PGV)
While protocol buffers effectively guarantee the types of structured data, 
they cannot enforce semantic rules for values. This package is a python implementation
of [protoc-gen-validate][pgv-home], which allows for runtime validation of various 
semantic assertions expressed as annotations on the protobuf schema. The syntax for all available annotations is
in `validate.proto`. Implemented Python annotations are listed in the [rules comparison][rules-comparison].

### Example
```python3
from entities_pb2 import Person
from protoc_gen_validate.validator import validate, ValidationFailed, validate_all

p = Person(name="Foo")
try:
    validate(p)
except ValidationFailed as err:
    print(err)  # p.id is not greater than 999
    
try:
    validate_all(p)
except ValidationFailed as err:
    print(err)  
    # p.id is not greater than 999
    # p.email is not a valid email
    # p.name pattern does not match ^[A-Za-z]+( [A-Za-z]+)*$
    # home is required.
```

[pgv-home]: https://github.com/envoyproxy/protoc-gen-validate
[rules-comparison]: https://github.com/envoyproxy/protoc-gen-validate/blob/main/rule_comparison.md
libretificacaotjcore 0.1.87
Biblioteca para centralizar conexao com filas no rabbit e banco de dados no mongodb para os servicos de retificacao da TJ
Requires Python: >=3.13
Keywords: tj, tributo justo, retificação, automação, pydantic, rabbitmq, boto3, motor

# 🛠️ LIBRETIFICACAOTJCORE

## 📝 Descrição

O Objetivo desse serviço é:
- Centralizar conexão com filas no rabbit e consumo de mensagens
- Centralizar conexão banco de dados no mongodb para os serviços de retificação da TJ
- Centralizar todas as operações de criação, leitura e atualização de arquivos
- Centralizar todas as operações de criação, leitura e atualização de protocolos
- Disponibilizar metodos para tratativas de arquivos
- Disponibilizar Dtos e Enums comuns em todos os serviços de retificações

## ⚙️ Configuração
nessesário ter o [uv astral](https://docs.astral.sh/uv/getting-started/installation/) instalado

Com o UV instalado, execute o comando abaixo para criar o arquivo de configuração:

```bash
    uv sync
```

## 📺 Como publicar?

Para publicar o serviço, execute o comando abaixo:

```bash
    uv build
```
e depois

```bash
    twine upload dist/*
```

Obs: É necessário informa o token do pypi para que o comando funcione
foxops-client 0.5.0
Foxops API Client
Requires Python: <4.0,>=3.14

# foxops-client-python

This repository contains the Python client for the [foxops](https://github.com/roche/foxops) templating tool.

## Installation

```shell
pip install foxops-client
```

## Usage

```python
from foxops_client import FoxopsClient, AsyncFoxopsClient

client = FoxopsClient("http://localhost:8080", "my-token")
incarnations = client.list_incarnations()

# or alternatively, the async version
client = AsyncFoxopsClient("http://localhost:8080", "my-token")
incarnations = await client.list_incarnations()
```
dtachwrap 0.1.1
Python wrapper for dtach with built-in binary management
Requires Python: >=3.10

# dtachwrap

Python wrapper for **dtach** with built-in binary management and multi-task CLI.
It packages the `dtach` binary in the wheel (Linux x86_64 / aarch64), so it works out of the box without compilation during installation.

## Features

- **Portable**: Includes pre-compiled `dtach` binaries (GPL compliant).
- **Easy Management**: `start`, `attach`, `ls`, `logs`, `stop` commands.
- **Logging**: Automatically captures stdout/stderr to files.
- **Recovery**: Keeps tasks running even if you disconnect.

## Installation

```bash
pip install dtachwrap
```

Or run directly with `uvx`:

```bash
uvx dtachwrap start my-task -- python script.py
```

## Usage

### Start a task

```bash
dtachwrap start train-exp1 -- python train.py --cfg exp1.yaml
```

The task runs in the background.

- Socket: `~/.dtachwrap/sockets/train-exp1`
- Logs: `~/.dtachwrap/logs/train-exp1.out`

### List tasks

```bash
dtachwrap ls
```

Shows running tasks. Use `dtachwrap ls --all` to see stopped tasks.

### View logs

```bash
dtachwrap logs train-exp1 -f
```

### Attach to a task

```bash
dtachwrap attach train-exp1
```

- Detach key: `^\` (Ctrl+\)
- Redraw: `Ctrl+l`

### Stop a task

```bash
dtachwrap stop train-exp1
```

## License

This project is licensed under MIT.
The bundled `dtach` binary is GPL-2.0. See `src/dtachwrap/_vendor/licenses/DTACH_COPYING`.

## Development

This project uses `uv` for dependency management.

1. **Setup**:
   ```bash
   uv sync
   ```

2. **Run locally**:
   ```bash
   uv run dtachwrap --help
   ```

3. **Build**:
   ```bash
   uv build
   ```
topsis-aishlee-102316083 0.3
TOPSIS command-line implementation in Python


# TOPSIS Assignment

TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) is a multi-criteria decision-making method.

This package provides a command-line implementation of the TOPSIS method in Python. It helps users rank multiple alternatives based on different criteria, weights, and impacts.

## Features
- Accepts CSV input files
- Supports user-defined weights and impacts
- Handles invalid inputs and errors
- Generates ranked output with TOPSIS scores
- Easy to use command-line interface

## Installation
pip install topsis-aishlee-102316083

## Usage
topsis input.csv weights impacts output.csv

Example:
topsis data.csv 1,1,1,1,1 +,+,+,+,+ result.csv

## Author
Aishlee Joshi
stakefish-web3-utils 0.10.3
Stakefish’s web3 utils for Python
Requires Python: >=3.9

.. image:: https://img.shields.io/pypi/v/stakefish-web3-utils.svg
   :target: https://pypi.org/project/stakefish-web3-utils

.. image:: https://img.shields.io/pypi/pyversions/stakefish-web3-utils.svg

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/psf/black
   :alt: Code style: Black


See the `Installation Instructions
<https://packaging.python.org/installing/>`_ in the Python Packaging
User's Guide for instructions on installing, upgrading, and uninstalling
stakefish-web3-utils.

Questions and comments should be directed to `GitHub Discussions
<https://github.com/stakefish/web3-utils.py/discussions>`_.
Bug reports and especially tested patches may be
submitted directly to the `bug tracker
<https://github.com/stakefish/web3-utils.py/issues>`_.
agentgog 0.1.16
Add your description here
Requires Python: >=3.12

# agentgog

CLI assistant that classifies short messages into **CALENDAR**, **TASK**, or **MEMO** and then:

- **CALENDAR** → extracts event details and inserts into **Google Calendar**
- **TASK** → extracts task details and inserts into **Google Tasks**
- **MEMO** → extracts memo details and saves to **Simplenote**

It also provides a general **chat** command, plus extra utilities (**translator**, **qrpayment**, **codeagent**).

## Install

This repo uses `uv`.

```bash
uv sync
```

Run from source:

```bash
uv run agentgog --help
```

## AI Provider setup

### OpenRouter (default)

Set API key via env var (preferred):

```bash
export OPENROUTER_API_KEY="<your_key>"
```

Or put the key in:

- `~/.openai_openrouter.key`

### Ollama (local)

Install and start Ollama:

```bash
ollama serve
```

Then use `-p ollama`.

## Google setup (Calendar + Tasks)

1. Create OAuth client credentials in Google Cloud Console.
2. Save the JSON to:

- `~/.config/google/credentials.json`

On first run, a browser window opens for authorization and a token is cached at:

- `~/.config/google/token.json`

If you ever change scopes and get “insufficient authentication scopes”, delete the token and re-run:

```bash
rm -f ~/.config/google/token.json
```

## Simplenote setup (MEMO)

Set credentials via environment variables:

```bash
export SIMPLENOTE_LOCAL_USER="user@example.com"
export SIMPLENOTE_LOCAL_PASSWORD="<your_password>"
```

## Usage

### Classify and execute

```bash
# Calendar event → Google Calendar
uv run agentgog classify "Meeting with Alice tomorrow at 10am"

# Task → Google Tasks (list: "My Tasks"; falls back to default)
uv run agentgog classify "Buy groceries tomorrow"

# Memo → Simplenote
uv run agentgog classify "Remember that my passport number is 123456789"
```

### Choose provider

```bash
# Use OpenRouter explicitly
uv run agentgog classify "Buy groceries" -p openrouter

# Use local Ollama
uv run agentgog classify "Buy groceries" -p ollama
```

### Chat

Single prompt:

```bash
uv run agentgog chat "Explain the difference between TCP and UDP"
```

Interactive chat (keeps conversation history in-memory):

```bash
uv run agentgog chat -i
```

Interactive commands:
- Quit: `/q`, `/quit`, `/exit`, `quit`, `exit`
- Clear conversation: `/c`, `/clear`, `/reset`, `/r`

Input line editing + persistent command history:
- History file: `~/.agentgog_history`

### Translator (SRT → Czech)

Uses `smolagents` (OpenRouter only):

```bash
uv run agentgog translator -s subtitles.srt -m google/gemma-3-27b-it:free
```

### QR payment

Uses `smolagents` (OpenRouter only):

```bash
uv run agentgog qrpayment "Transfer 500 CZK to account 1234567890/0300" -m google/gemma-3-27b-it:free
```

### Code agent

Uses `smolagents`:

```bash
uv run agentgog codeagent "Write a Python function to compute fibonacci" -m google/gemma-3-27b-it:free -x 10
```

## Logging

- Log file: `~/agentgog.log`
jac-super 0.1.4
Enhanced console output for Jac CLI with Rich formatting
Requires Python: >=3.12
Keywords: jac, jaclang, jaseci, console, rich, cli

# Jac Super

Enhanced console output plugin for Jac CLI with Rich formatting.

## Installation

```bash
pip install jac-super
```

Once installed, the plugin automatically registers and enhances all Jac CLI command output.

## Usage

No configuration required. After installation, jac-super automatically enhances output for all Jac commands:

- `jac create` - Enhanced project creation messages
- `jac start` - Server startup and status messages
- `jac run` - Formatted execution output
- `jac config` - Styled configuration display

## Environment Variables

| Variable | Effect |
|----------|--------|
| `NO_COLOR` | Disables colors (fallback to base console) |
| `NO_EMOJI` | Disables emojis (uses text labels) |
| `TERM=dumb` | Disables both colors and emojis |
empfin 1.9
Empirical Finance Tools
Keywords: asset pricing, empirical asset pricing, empirical finance, factor models, finance, risk premia


# empfin - Empirical Finance Tools in Python
`empfin` is a Python toolkit for empirical asset pricing models and risk premia estimation. This library is in active development and aims to implement models from all corners of the literature.

# What's Inside
Currently available models for estimation of risk premia:
- `TimeseriesReg`: single-pass OLS time-series regression, described in [Cochrane (2005)](https://press.princeton.edu/books/hardcover/9780691121376/asset-pricing?srsltid=AfmBOoobXP_DmuPEfu1g7gm1ppk4h69GFHtwJqq0ugoZwSYKW60gLXZ6), Section 12.1
- `CrossSectionReg`: two-pass cross-sectional regression, described in [Cochrane (2005)](https://press.princeton.edu/books/hardcover/9780691121376/asset-pricing?srsltid=AfmBOoobXP_DmuPEfu1g7gm1ppk4h69GFHtwJqq0ugoZwSYKW60gLXZ6), Section 12.2
- `NonTradableFactors`: iterative maximum-likelihood estimator for non-tradable factors, described in [Campbell, Lo & MacKinlay (2012)](https://www.amazon.com/Econometrics-Financial-Markets-John-Campbell/dp/0691043019), Section 6.2.3 
- `RiskPremiaTermStructure`: term structure of risk premia with a single factor, tradable or not, following [Bryzgalova, Huang & Julliard (2024)](https://doi.org/10.2139/ssrn.4752696). I would like to thank the authors for sharing their replication files.

# Examples
For each model, there is a jupyter notebook with [examples](https://github.com/gusamarante/empfin/tree/main/examples) of their use.

# Installation
```bash
pip install empfin
```

# References
Bryzgalova, Huang, and Julliard (2024) [“_Macro Strikes Back: Term Structure of Risk Premia_”](https://doi.org/10.2139/ssrn.4752696) Working Paper

Cochrane (2005) ["_Asset Pricing: Revised Edition_"](https://press.princeton.edu/books/hardcover/9780691121376/asset-pricing?srsltid=AfmBOoobXP_DmuPEfu1g7gm1ppk4h69GFHtwJqq0ugoZwSYKW60gLXZ6). Princeton University Press.

Campbell, Lo, and MacKinlay (2012) ["_The Econometrics of Financial Markets_"](https://www.amazon.com/Econometrics-Financial-Markets-John-Campbell/dp/0691043019)

# Library Citation
> Gustavo Amarante (2026). empfin - Empirical Finance Tools in Python. Retrieved from https://github.com/gusamarante/empfin