semvec/pypi-packages huggingface dataset:
grpc-orchestrator 0.0.6
A gRPC-based Saga Orchestration System for distributed transactions
Requires Python: >=3.7
Keywords: grpc, grpc orchestrator, grpc microservices, distributed transactions, python grpc, saga pattern, grpc saga, transaction orchestrator, python microservices

# ðŸ§© grpc-orchestrator

**`grpc-orchestrator`** is a lightweight, gRPC-based Saga orchestration system for coordinating distributed transactions across microservices. It helps ensure data consistency by executing a series of steps with compensating rollbacks in case of failures.

---

## ðŸš€ Key Features

- **Saga Pattern Implementation**: Coordinates multi-step transactions with compensation support for failures.
- **gRPC-Native Architecture**: Fast and type-safe communication using Protocol Buffers and gRPC.
- **Flexible Step Definition**: Each step supports service, method, timeout, and optional compensation logic.
- **Asynchronous Orchestration**: Steps execute in order, compensation runs in reverse on failure.
- **In-Memory Storage**: Ideal for prototyping and testing. Easily swappable for custom persistent backends.
- **Execution Logging**: Tracks timestamps, success/failure, payloads, and error messages per step.

---

## ðŸ“¦ Components

### 1. Protobuf APIs

Defines the orchestrator and participant interfaces:

```proto
service SagaOrchestratorService {
  rpc StartSagaTransaction (StartSagaRequest) returns (StartSagaResponse);
  rpc GetSagaStatusTransaction (GetSagaStatusRequest) returns (GetSagaStatusResponse);
}

service SagaParticipant {
  rpc Execute (SagaParticipantRequest) returns (SagaParticipantResponse);
  rpc Compensate (SagaParticipantRequest) returns (SagaParticipantResponse);
}

###pip install grpc_orchestrator

```python

from grpc_orchestrator.core.client.client import GrpcOrchestratorClient

client = GrpcOrchestratorClient(orchestrator_host="localhost")
steps = [
    {
        "port": 50052,
        "rpc_method": "CleateOrder",
        "compensation_method": "RollbackOrder",
        "timeout_seconds": 5,
    },
    {
        "port": 50052,
        "rpc_method": "CheckoutOrder",
        "compensation_method": "CheckoutOrder",
        "timeout_seconds": 5,
    },
]
client.start_transaction(transaction_id="1234",steps=steps,payload={
    "id": "1",
    "name":"item1"
})

status = client.get_transaction_status(transaction_id="order_123")
print(status)

![Saga Flow Diagram](grpc_orchestrator/images/flow.png)
loglikelihood-estimator-1 0.1.0
Log-likelihood estimator for stochastic frontier models with endogeneity (LIML component)
Requires Python: >=3.7

# Log-Likelihood Estimator

This package provides functions for simulating datasets, estimating log-likelihood values, and calculating the UCI value and conditional variance \( \sigma_c^2 \).

## Installation

You can install the package from PyPI (if uploaded) or directly from the source:

```bash
pip install loglikelihood_estimator_1
lightblue-ai 0.5.7
Light Blue is an agentic agent framework for building AI applications
Requires Python: <4.0,>=3.10
Keywords: agent, agentic, llm

# lightblue-ai

[![Release](https://img.shields.io/github/v/release/ai-zerolab/lightblue-ai)](https://img.shields.io/github/v/release/ai-zerolab/lightblue-ai)
[![Build status](https://img.shields.io/github/actions/workflow/status/ai-zerolab/lightblue-ai/main.yml?branch=main)](https://github.com/ai-zerolab/lightblue-ai/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/ai-zerolab/lightblue-ai/branch/main/graph/badge.svg)](https://codecov.io/gh/ai-zerolab/lightblue-ai)
[![Commit activity](https://img.shields.io/github/commit-activity/m/ai-zerolab/lightblue-ai)](https://img.shields.io/github/commit-activity/m/ai-zerolab/lightblue-ai)
[![License](https://img.shields.io/github/license/ai-zerolab/lightblue-ai)](https://img.shields.io/github/license/ai-zerolab/lightblue-ai)

> Inspired by Deep Blue – Harnessing computational power to transcend human design.
>
> [The Bitter Lesson](http://www.incompleteideas.net/IncIdeas/BitterLesson.html)
>
> [The Bitter Lesson: Rethinking How We Build AI Systems](https://ankitmaloo.com/bitter-lesson/)

Light Blue is an agentic agent framework for building AI applications.

- **Github repository**: <https://github.com/ai-zerolab/lightblue-ai/>

## Usage

### CLI

#### Stream

Directly prompt:

```bash
uvx lightblue-ai stream <prompt>
```

Use prompt file:

```bash
uvx lightblue-ai stream prompt.md # Or just uvx lightblue-ai stream, prompt.md is the default prompt file
```

#### Submit

Directly prompt:

```bash
uvx lightblue-ai submit <prompt>
```

Use prompt file:

```bash
uvx lightblue-ai submit prompt.md # Or just uvx lightblue-ai submit, prompt.md is the default prompt file
```

### Programmatic

See [agent.py](./lightblue_ai/agent.py) and [Examples](./examples/README.md)

## Configuration

- `prompt.md` use this file as the user prompt
- `system_prompt.md` to Override [system prompt](./lightblue_ai/prompts/templates/system_prompt.md)
- `mcp.json` to configure [MCP](./mcp.example.json)
- `.env` for [setting environment variables](./.env.example)

Once you provided the api-key of the tools, tools will automatically be loaded.

## Tools

### PDF to Image

You need to install poppler for pdf to image conversion

#### Mac

Mac users will have to install poppler for pdf to image conversion

Installing using Brew:

```bash
brew install poppler
```

#### Linux

Most distros ship with pdftoppm and pdftocairo. If they are not installed, refer to your package manager to install poppler-utils. e.g. `apt-get install poppler-utils`

### HTML View as Image

you need to run `playwright install` or `uv tool run playwright install` to install chromium and dependencies.
types-click-default-group 1.2.0.20250513
Typing stubs for click-default-group
Requires Python: >=3.9

## Typing stubs for click-default-group

This is a [PEP 561](https://peps.python.org/pep-0561/)
type stub package for the [`click-default-group`](https://github.com/click-contrib/click-default-group) package.
It can be used by type-checking tools like
[mypy](https://github.com/python/mypy/),
[pyright](https://github.com/microsoft/pyright),
[pytype](https://github.com/google/pytype/),
[Pyre](https://pyre-check.org/),
PyCharm, etc. to check code that uses `click-default-group`. This version of
`types-click-default-group` aims to provide accurate annotations for
`click-default-group==1.2.*`.

This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/click-default-group`](https://github.com/python/typeshed/tree/main/stubs/click-default-group)
directory.

This package was tested with
mypy 1.15.0,
pyright 1.1.400,
and pytype 2024.10.11.
It was generated from typeshed commit
[`8b877a6993cf183f865a2c11c1f89adb6156f5c0`](https://github.com/python/typeshed/commit/8b877a6993cf183f865a2c11c1f89adb6156f5c0).
sf-helper 0.0.2
A sample CLI project build with Poetry.
Requires Python: <4.0,>=3.8

# sf-helper

A command-line interface (CLI) tool to simplify backing up Salesforce metadata.

## Overview

`sf-helper` is a Python-based CLI tool that helps Salesforce administrators and developers back up metadata from their Salesforce orgs. It streamlines the process of retrieving metadata components, such as objects, workflows, and profiles, and saves them to a local directory for version control or archival purposes.

## Features

- Backup Salesforce metadata with a single command.
- Support for multiple metadata types (e.g., Apex classes, custom objects, profiles).
- Configurable output directory for backups.
- Secure storage of Salesforce credentials (API key/token).

## Installation

### Prerequisites
- Python 3.8 or higher
- `pip` (Python package manager)
- Salesforce account with API access

### Steps
1. Install `sf-helper` using pip:
   ```bash
   pip install sf-helper
   ```
## Configuration

Before using `sf-helper`, set up your Salesforce API key or access token:

```bash
sf-helper set-key --api-key <your-api-key>
```

This stores the API key securely in a configuration file (`~/.sf_helper_config.ini`).

## Usage

### Backup Metadata
To back up metadata to a local directory:
**Not Yet Implemented**
```bash
sf-helper backup --output-dir ./salesforce-backup
```

This retrieves metadata from your Salesforce org and saves it to the specified directory.

### Specify Metadata Types
**Not Yet Implemented**
To back up specific metadata types (e.g., custom objects and profiles):

```bash
sf-helper backup --output-dir ./salesforce-backup --types CustomObject,Profile
```

### View Stored API Key
To check the stored API key:

```bash
sf-helper get-key
```

### Help
To see all available commands and options:

```bash
sf-helper --help
```

## Example

```bash
# Set API key
sf-helper set-key --api-key my-secret-key-123

# Backup all metadata (Not yet implemented)
sf-helper backup --output-dir ./my-backups

# Backup specific metadata types (Not yet implemented)
sf-helper backup --output-dir ./my-backups --types ApexClass,CustomObject
```

## Contributing

Contributions are welcome! To contribute:
1. Fork the repository.
2. Create a feature branch (`git checkout -b feature/YourFeature`).
3. Commit your changes (`git commit -m 'Add YourFeature'`).
4. Push to the branch (`git push origin feature/YourFeature`).
5. Open a pull request.

## License

This project is licensed under the MIT License.

## Support

For issues or questions, please open an issue on the [GitHub repository](https://github.com/yourusername/sf-helper).
ciphers-vbcd-testing2 0.2.0
A tool for ciphering messages using various algorithms
Requires Python: >=3.9

# Ciphers

A Python tool for ciphering messages using various algorithms.

## Installation

### Basic Installation

```bash
pip install ciphers-vbc
```

### With RSA Support

```bash
pip install ciphers-vbc[rsa]
```

### Using uv (recommended)

```bash
# Install uv if you don't have it
pip install uv

# Create and activate a virtual environment with uv
uv venv
source .venv/bin/activate  # On Linux/macOS
# or
# .venv\Scripts\activate  # On Windows

# Install the package in development mode
uv pip install -e .

# With RSA support
uv pip install -e ".[rsa]"
```

### Using pip

```bash
pip install -e .

# With RSA support
pip install -e ".[rsa]"
```

## Usage

### Caesar Cipher

```bash
# Encrypt a message using Caesar cipher with a shift of 3
cipher encrypt --algorithm caesar --key 3 "Hello, World!"

# Decrypt a message using Caesar cipher with a shift of 3
cipher decrypt --algorithm caesar --key 3 "Khoor, Zruog!"
```

### RSA Cipher

First, generate an RSA key pair:

```bash
# Using OpenSSL
openssl genrsa -out private_key.pem 2048
openssl rsa -in private_key.pem -pubout -out public_key.pem
```

Then encrypt and decrypt messages:

```bash
# Encrypt a message using RSA with a public key
cipher encrypt --algorithm rsa --key public_key.pem "Secret message"

# Decrypt a message using RSA with a private key
cipher decrypt --algorithm rsa --key private_key.pem "encrypted_message_here"
```

## Development

### Installing Development Dependencies

With uv:

```bash
# Install development dependencies
uv pip install -e ".[dev]"
```

With pip:

```bash
# Install development dependencies
pip install -e ".[dev]"
```

### Running Tests

```bash
# Run tests with pytest
pytest

# Run tests with coverage
pytest --cov=ciphers
```

### Code Formatting and Linting

```bash
# Format code with black
black .

# Sort imports with isort
isort .

# Lint with ruff
ruff check .

# Format with ruff
ruff format .

# Type checking with mypy
mypy ciphers tests
```

### Building and Publishing

Building the package with uv:

```bash
# Build both wheel and sdist
uv build .

# Or build specific formats
uv build --wheel .  # Only wheel
uv build --sdist .  # Only source distribution
```

Publishing to PyPI with uv:

```bash
# Upload to TestPyPI first to verify everything works
uv publish --index testpypi dist/*

# Upload to PyPI
uv publish dist/*
```

You can also use twine if you prefer:

```bash
# Install twine
uv pip install twine

# Upload to TestPyPI
python -m twine upload --repository testpypi dist/*

# Upload to PyPI
python -m twine upload dist/*
```

## Supported Algorithms

- Caesar Cipher: A simple substitution cipher where each letter is shifted by a fixed number of positions.
- RSA Cipher: A public-key cryptosystem that uses asymmetric encryption for secure data transmission.
python-version-controller 1.2.1
PyVCC python version controller using conventional commits
Requires Python: >=3.10

# python-version-controller
conventional version controller for python

[![codecov](https://codecov.io/gh/lcavalcante/python-version-controller/graph/badge.svg?token=H65NZV7N3Z)](https://codecov.io/gh/lcavalcante/python-version-controller)
[![tests](https://github.com/lcavalcante/python-version-controller/actions/workflows/code-quality.yml/badge.svg)](https://github.com/lcavalcante/python-version-controller/actions/workflows/code-quality.yml)