semvec/pypi-packages huggingface dataset:
llm-assistant-framework 0.1.0
A flexible framework for building AI assistants using various LLMs
Requires Python: >=3.7

# LLM Assistant Framework

LLM Assistant Framework is a flexible and powerful Python library for building AI assistants using various Large Language Models (LLMs). Inspired by OpenAI's Assistants API, this framework allows you to create, manage, and interact with AI assistants using different LLM providers.

## Features

- 🚀 Easy-to-use API for creating and managing AI assistants
- 🔌 Flexible integration with multiple LLM providers
- 💬 Thread-based conversation management
- 🏃‍♂️ Asynchronous execution of assistant runs
- 🛠️ Customizable and extensible architecture

## Installation

You can install the LLM Assistant Framework using pip:

```bash
pip install llm-assistant-framework
```

## Usage

```python
from llm_assistant_framework import AssistantManager, ThreadManager, RunManager

# Initialize managers
assistant_manager = AssistantManager()
thread_manager = ThreadManager()
run_manager = RunManager(assistant_manager, thread_manager)

# Create an assistant with the custom LLM function
assistant = await assistant_manager.create_assistant(
    name="Sky Expert",
    instructions="You are an expert on atmospheric phenomena.",
    model="llama3",
    custom_llm_function=custom_llm_function,
    temperature=0.7,  # Additional parameter for the LLM
)
print(assistant)

# Create a thread
thread = await thread_manager.create_thread()
print(thread)
```

## Contributing

We welcome contributions to the LLM Assistant Framework! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.

## License

This project is licensed under the MIT License. See the LICENSE file for more details.
docker-recreate 1.4.5
Get docker run command from container

# docker recreate tools

This is a small tool to print re-create existance docker container run commands.

# Install

```bash
# through pip
pip install docker-recreate


# using curl
curl https://raw.githubusercontent.com/jeffrey4l/docker-recreate/master/main.py \
    -o /usr/local/bin/docker-recreate
chmod +x /usr/local/bin/docker-recreate


# for China
curl https://raw.fastgit.org/jeffrey4l/docker-recreate/master/main.py \
    -o /usr/local/bin/docker-recreate
chmod +x /usr/local/bin/docker-recreate
```

# Usage

```console
$ docker-recreate -h
usage: docker-recreate [-h] [--format {csv,json,oneline,string,yaml}] container [container ...]

positional arguments:
  container

optional arguments:
  -h, --help            show this help message and exit
  --format {csv,json,oneline,string,yaml}, -f {csv,json,oneline,string,yaml}
```

```console
$ docker-create grafana
docker \
    run \
    -d \
    --name grafana \
    --network host \
    --restart always \
    -v grafana:/var/lib/grafana:rw \
    grafana/grafana:8.0.3
```

```console
$ docker-recreate ceph_osd_2
docker \
    run \
    -d \
    --name ceph_osd_2 \
    --network host \
    --restart unless-stopped \
    --pid host \
    --privileged \
    -e OSD_STORETYPE=filestore \
    -e OSD_BS_FSUUID=e76f38d0-3f34-4771-b099-d26ee063ae01 \
    -e OSD_ID=2 \
    -e KOLLA_CONFIG_STRATEGY=COPY_ALWAYS \
    -e JOURNAL_PARTITION=/dev/disk/by-partuuid/9967b401-ff2b-4ed4-ac15-028e89238bdf \
    -e TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=134217728 \
    -e KOLLA_SERVICE_NAME=ceph-osd-2 \
    -v kolla_logs:/var/log/kolla/:rw \
    -v /etc/localtime:/etc/localtime:ro \
    -v /etc/kolla/ceph-osd/:/var/lib/kolla/config_files/:ro \
    -v /dev/:/dev/:rw \
    -v /var/lib/ceph/osd/e76f38d0-3f34-4771-b099-d26ee063ae01:/var/lib/ceph/osd/ceph-2:rw \
    172.20.140.229:4000/kolla/centos-source-ceph-osd:train
```
bidsapp-helper 0.1.0
Python helper package to simplify creation of BIDS apps
Requires Python: >=3.11
Keywords: argparse, bids, neuroimaging

# BIDS-app helper

Helper package to simplify creation of BIDS apps.

## Installation

<!--
Install this package via :

```sh
pip install bidsapp_cli
``` -->

<!-- Or get the newest development version via: -->

Get the newest development version:

```sh
pip install git+https://github.com/kaitj/bidsapp-helper
```

## Quick start

Short tutorial, maybe with a

```Python
from bidsapp_helper.parser import BidsAppArgumentParser

parser = BidsAppArgumentParser(
    app_name="app",
    description="Short description of application"
)
args = parser.parse_args()
```

# Features

- CLI initialization
- Pipeline descriptor

## Links or References

- [BIDS apps](https://bids-apps.neuroimaging.io/about/)
faststream-deadline-propagation 0.1.2
A middleware for the FastStream framework that provides deadline-propagation in Remote Procedure Call requests
Requires Python: <4.0,>=3.11

# faststream-deadline-propagation

A middleware for the FastStream framework that provides deadline-propagation in Remote Procedure
Call requests. It ensures that messages are processed within a specified timeout period, raising
an exception if the deadline is exceeded.

## Features

- **Deadline Processing Middleware**: Ensures that message processing is completed within a 
specified deadline.
- **Deadline Publishing Middleware**: Adds a deadline header to messages being published, 
ensuring they are processed within the specified timeout.
- **Customizable Header**: Allows customization of the header used for deadlines.
- **Exception Handling**: Raises a `DeadlineOccurred` exception if the deadline is exceeded.

## Example

```python
import asyncio
from datetime import datetime, timedelta
from typing import Any

from faststream import FastStream
from faststream.nats import NatsBroker, NatsRouter

from faststream_deadline_propagation import (
    DeadlineCountdown,
    DeadlineProcessMiddleware,
    DeadlinePublishMiddleware,
)

rpc_router = NatsRouter(
    middlewares=(
        DeadlineProcessMiddleware.make_middleware(),
        # Your other middlewares here
    )
)
broker = NatsBroker(
    middlewares=(
        # Your other middlewares here
        DeadlinePublishMiddleware.make_middleware(),
    )
)


@rpc_router.subscriber("something")
async def do_nothing(message: Any, countdown: DeadlineCountdown):
    await asyncio.sleep(1)

    # current timeout in seconds
    current_timeout: float = countdown()
    print(current_timeout)


broker.include_routers(rpc_router)
app = FastStream(broker)


@app.after_startup
async def publisher():
    # You can specify a timeout and the DeadlinePublishMiddleware will automatically
    # add the header
    await broker.request(123, "something", timeout=3)

    # Or explicitly specify the header with your deadline, in this case, the header value
    # will not be overridden
    await broker.request(
        123,
        "something",
        timeout=3,
        headers={"x-deadline": (datetime.now() + timedelta(seconds=1)).isoformat()},
    )
```

To handle the `DeadlineOccurred` error and serialize the response, you should use the 
[`ExceptionMiddleware`](https://faststream.airt.ai/latest/getting-started/middlewares/exception/) 
built into FastStream.
labinform-datasafe 0.1.0b1
A local repository for warm research data
Requires Python: >=3.7
Keywords: Reproducible research, data storage, repository, warm research data, checksums

LabInform Datasafe
==================

*A local repository for "warm" research data.*

The LabInform datasafe is the **data store for "warm" research data** that is part of the `LabInform laboratory information and management system <https://www.labinform.de/>`_ (LIMS). One key aspect of handling data is to store them in one place and access them via unique identifiers (here: a *Lab Object Identifier*, LOI).



Features
========

A list of features, not all implemented yet but aimed at for the first public release:

* Client-server architecture

* Local install as well as network install possible

* Automatic generation of unique LOIs


And to make it even more convenient for users and future-proof:

* Open source project written in Python (>= 3.7)

* Developed fully test-driven

* Extensive user and API documentation


Warning

The dataset component of the LabInform project is currently under active development and still considered in Alpha development state. Therefore, expect frequent changes in features and public APIs that may break your own code. Nevertheless, feedback as well as feature requests are highly welcome.


Requirements
============

The LabInform datasafe package comes with a rather minimal set of requirements:

* Python >= 3.7
* flask and oyaml packages


Installation
============

To install the LabInform datasafe package on your computer (sensibly within a Python virtual environment), open a terminal (activate your virtual environment), and type in the following:

.. code-block:: bash

    pip install labinform-datasafe


License
=======

This program is free software: you can redistribute it and/or modify it under the terms of the **BSD License**.


Contributing
============

If you would like to contribute, the easiest may be to clone the repository. In this case, don't forget to add the version incrementer residing in ``./bin/incrementVersion.sh`` to your git pre-commit hook in `./.git/hooks/pre-commit`` (or create this file if it doesn't exist yet)::

    #!/usr/bin/env bash
    ./bin/incrementVersion.sh

In case you needed to create the file ``pre-commit``, don't forget to make it executable (using ``chmod +x <file>``).
validador-docs 0.0.1
Validators Brasilian documents
Requires Python: >=3.12

# Validator Docs
A Python package to validate and format Brazilian CPF and CNPJ documents.

## Features
- **CPF Validation**: Check if a given CPF is valid by verifying its check digits.
- **CNPJ Validation**: Validate CNPJ numbers by calculating their check digits.
- **CPF and CNPJ Formatting**: Format CPF and CNPJ numbers to standard Brazilian formats.

## Installation
You can install the package via `pip`:
```bash
pip install validator_docs
```
## Usage
### Import the package
> from validator_docs import validar_doc, formatar_cpf, formatar_cnpj

### Validate CPF and CNPJ
To validate a CPF or CNPJ, simply pass the document number (either as a string or integer) to the `validar_doc` function. The function will raise an exception if the document is invalid.
```
# Validate CPF
cpf = "123.456.789-09"
try:
    valid_cpf = validar_doc(cpf)
    print(f"CPF {valid_cpf} is valid.")
except ValueError as e:
    print(e)

# Validate CNPJ
cnpj = "12.345.678/0001-95"
try:
    valid_cnpj = validar_doc(cnpj)
    print(f"CNPJ {valid_cnpj} is valid.")
except ValueError as e:
    print(e)

```
### Format CPF and CNPJ

You can format valid CPF and CNPJ numbers using the provided `formatar_cpf` and `formatar_cnpj` functions:
```
cpf = "12345678909"
formatted_cpf = formatar_cpf(cpf)
print(f"Formatted CPF: {formatted_cpf}")  # Output: 123.456.789-09

cnpj = "12345678000195"
formatted_cnpj = formatar_cnpj(cnpj)
print(f"Formatted CNPJ: {formatted_cnpj}")  # Output: 12.345.678/0001-95
```
### Full Example

Here's a full example of how to use `validator_docs` to validate and format both CPF and CNPJ numbers:

```
from validator_docs import validar_doc

cpf = "123.456.789-09"
cnpj = "12.345.678/0001-95"

# Validate CPF and CNPJ
try:
    valid_cpf = validar_doc(cpf, formatado=True)
    print(f"Valid CPF: {valid_cpf}")
    
    valid_cnpj = validar_doc(cnpj, formatado=True)
    print(f"Valid CNPJ: {valid_cnpj}")
    
except ValueError as e:
    print(e)
```
## Roadmap

-   Adding support for other document types.
-   Improving performance for batch document validations.
## License

This project is licensed under the MIT License - see the LICENSE file for details.
image-processing-fmsouza 0.0.1
Image processing Package using SKimage
Requires Python: >=3.5

# image-processing-fmsouza

Description. 
The package image-processing-fmsouza is used to:
	Processing:
		- Histrogram matching
		- Structural similarity
		- Resize image
	Utils:
		- Read image
		- Save image
		- Plot image
		- Plot result
		- Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image-processing-fmsouza

```bash
pip install image-processing-fmsouza
```

## Author
Felipe

## License
[MIT](https://choosealicense.com/licenses/mit/)
cli-agent 0.1.4
AI for CLI
Requires Python: <3.13,>=3.11

# CLI-Agent
Talk to cli-agent and it will help you to write bash code to solve your problem.
### Installation
```bash
pip install cli-agent
```

### Configuration
- Set the default model to use. 

Based on Litellm , so most of the models are supported (https://github.com/BerriAI/litellm)
```bash
cli config default_model <model_name>
```

- Set the default ask user behavior, when code is about to run it asks user if he wants to run it or not
  - always      # ask user always
  - never       # ask user never
  - sometimes   # ask user when llms suggests to ask
```bash
cli config ask_user <always|never|sometimes>
```

- Set the retry if generation fails
```bash
cli config retry_generation <number>
```
### Usage
Commands:

cli : main cli command
ci : direct chat with cli


1. Make call through the cli command
```bash
cli run 'kill the chrome' --model cerebras/llama3.1-70b
```
or 
```bash
ci 'convert this.mp4  to 720p and remove the audio' 
```

2. If error happens, you can fix it with the following command.

Error-report takes account of the last command it executed, so it will fix the error with the last command
```bash
ci ' also flip the video' --model openai/gpt-3.5-turbo --error-report
```

### command line interface
```bash
$ cli --help
Usage: cli [OPTIONS] COMMAND [ARGS]...

  CLI AI: Natural Language Command Line Interface

Options:
  --help  Show this message and exit.

Commands:
  config  View or set configuration values
  run     Run the main CLI AI application

$ cli run --help

Usage: cli run [OPTIONS] [USER_INPUT]...

  Run the main CLI AI application

Options:
  --n-hist INTEGER             Number of history items to consider
  --model TEXT                 Model name to use
  -er, --error-report BOOLEAN  Fix the last error with current modifications
  --help                       Show this message and exit.

```

### Recommended models
- cerebras (https://github.com/cerebras) #fastest model inference in the world on llama3.1-70b
- groq (https://github.com/simonw/groq) # 2nd Fastest model inference