semvec/pypi-packages huggingface dataset:
accelerate-python 1.0.5
Python utility package similar to apache-commons for Java
Requires Python: >=3.12

# Introduction 
TODO: Give a short introduction of your project. Let this section explain the objectives or the motivation behind this project. 

# Getting Started
TODO: Guide users through getting your code up and running on their own system. In this section you can talk about:
1.	Installation process
2.	Software dependencies
3.	Latest releases
4.	API references

# Build and Test
TODO: Describe and show how to build your code and run the tests. 

# Contribute
TODO: Explain how other users and developers can contribute to make your code better. 

If you want to learn more about creating good readme files then refer the following [guidelines](https://docs.microsoft.com/en-us/azure/devops/repos/git/create-a-readme?view=azure-devops). You can also seek inspiration from the below readme files:
- [ASP.NET Core](https://github.com/aspnet/Home)
- [Visual Studio Code](https://github.com/Microsoft/vscode)
- [Chakra Core](https://github.com/Microsoft/ChakraCore)
pypdffiller 1.0.0
Interact with PDF by inspecting or filling it
Requires Python: >=3.9
Keywords: development, pdf

pypdffiller
===========

|Test| |PyPI| |Python| |Code Style| |Pre-Commit| |License|

``pypdffiller`` is a free and open source pure-Python 3 library for PDF form processing. It contains the essential
functionalities needed to interact with PDF forms:

- Inspect what data a PDF form needs to be filled with.
- Fill a PDF form by simply creating a Python dictionary.

Installation
------------

As of first version, ``pypdffiller`` is compatible with Python 3.9+.

Use ``pip`` to install the latest stable version of ``pypdffiller``:

.. code-block:: console

   $ pip install --upgrade pypdffiller

The current development version is available on both `GitHub.com
<https://github.com/sismicfr/pypdffiller>`__ and can be
installed directly from the git repository:

.. code-block:: console

   $ pip install git+https://github.com/sismicfr/pypdffiller.git


Bug reports
-----------

Please report bugs and feature requests at
https://github.com/sismicfr/pypdffiller/issues.


Documentation
-------------

The full documentation for CLI and API is available at https://pypdffiller.readthedocs.org/en/stable/.

Build the docs
~~~~~~~~~~~~~~

We use ``tox`` to manage our environment and build the documentation:

.. code-block:: console

   $ pip install tox
   $ tox -e docs

Executable
----------

In addition to the **Python** package, a standalone executable can be built using **PyInstaller**.

Build the executable
~~~~~~~~~~~~~~~~~~~~

We use ``tox`` to manage our environment and build the executable:

.. code-block:: console

   $ pip install tox
   $ tox -e installer

.. code-block:: console

   $ make exe

Contributing
------------

For guidelines for contributing to ``pypdffiller``, refer to `CONTRIBUTING.rst <https://github.com/sismicfr/pypdffiller/blob/main/CONTRIBUTING.rst>`_.


.. |Test| image:: https://github.com/sismicfr/pypdffiller/workflows/Test/badge.svg
   :target: https://github.com/sismicfr/pypdffiller/actions
   :alt: Test

.. |PyPI| image:: https://img.shields.io/pypi/v/pypdffiller?label=PyPI&logo=pypi
   :target: https://badge.fury.io/py/pypdffiller
   :alt: PyPI

.. |Read the Docs| image:: https://img.shields.io/readthedocs/pypdffiller?label=Documentation&logo=Read%20the%20Docs
   :target: https://sismicfr.github.io/pypdffiller
   :alt: Docs

.. |Python| image:: https://img.shields.io/pypi/pyversions/pypdffiller.svg?label=Python&logo=Python
   :target: https://pypi.python.org/pypi/pypdffiller
   :alt: Python

.. |Code Style| image:: https://img.shields.io/badge/code%20style-black-000000.svg?label=Code%20Style
   :target: https://github.com/python/black
   :alt: Code Style

.. |Pre-Commit| image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&label=Pre-Commit
   :target: https://github.com/pre-commit/pre-commit
   :alt: Pre-Commit

.. |License| image:: https://img.shields.io/github/license/sismicfr/pypdffiller?label=License
   :target: https://github.com/sismicfr/pypdffiller/blob/main/COPYING
   :alt: License
salome-pybatch 1.0
Job management on remote computers.
Requires Python: >=3.9

# pybatch
Pybatch is a python module to submit jobs on a remote server managed by a batch manager such as Slurm, PBS, etc.

For the moment, the supported batch managers are:
- 'slurm'
- 'nobatch' - built in minimalistic solution when no batch manager is available.

# Install
For installation, you can download the sources and use python package installers such as 'pip' to install from sources.
You can download the sources here:
```
git clone https://codev-tuleap.cea.fr/plugins/git/salome/pybatch.git
```

There is also an internal repository for EDF users:
```
git clone https://gitlab.pleiade.edf.fr/I35256/pybatch.git
```

## Basic installation
The name of the pip package is *salome-pybatch*.
This installation uses minmalistic dependencies. The only python package used is 'psutil'.
```
pip install salome-pybatch
```
In this kind of installation, the only way to connect to a remote server is to use 'SshProtocol' which needs the 'ssh' external command to be already available on the workstation.

## Complete installation
This installation uses some additional dependencies in order to have a built in 'ssh' client.
These additional dependencies are :
- 'libkrb5-dev' linux package needed for kerberos authentication,
- 'paramiko' and 'scp' python packages.

```
pkcon install libkrb5-dev
pip install salome-pybatch[paramiko]
```
With this kind of installation you can use 'ParamikoProtocol' for remote connections, which does not use any external program.

'ParamikoProtocol' is more efficient than 'SshProtocol', because it uses a single
ssh session and a single authetication for the management of the whole job, while
'SshProtocol' needs a new connection with a new authentication for every operation.

## Development tools
The development evironment can be installed by :
```
pip install salome-pybatch[dev]
```
The main development tool is 'tox', which manages the environments for tests,
documentation generation and code quality checks.

# Exemple of use

[Use case with comments.](doc/examples/use_case.py)

# Documentation
The documentation can be generated from sources, in the source directory, with:
```
tox -e docs
firefox build/docs/interface/html/index.html
```

# Tests
Pybatch tests use 'pytest' for execution and 'tox' for the management of the python environment.
There are three kinds of tests :
1. tests that can be run on the local workstation without any additional data,
2. tests that need a remote ssh server,
3. tests that need 'Slurm', localy or remotely

The first category of tests can be executed from the sources directory by the command :
```
tox -e test
```
The other tests need a configuration file :
```
tox -e test -- --user-config-file=path/to/config_tests.toml
```
The configuration file defines the adress of the remote server, the type of tests that could be run and some other data needed by the test.
An example of configuration file is available [here](doc/examples/config_tests.toml).
musicgen-trainer 1.0.1
A module for advanced music generation and synthesis.
Requires Python: >=3.6

# Musicgen Trainer

Musicgen Trainer is an advanced Python module designed for music generation and synthesis. It provides tools for creating MIDI files, integrating pretrained models, and dynamically controlling parameters like tempo and key. This package is ideal for developers, musicians, and researchers looking to explore AI-driven music creation.

## Features

- **MIDI-Based Music Generation**: Generate MIDI files with customizable parameters such as tempo and key.
- **Pretrained Model Integration**: Load and use pretrained models for advanced music generation.
- **Dynamic Parameter Control**: Adjust tempo, key, and other musical attributes during generation.
- **Data Augmentation**: Enhance input sequences with noise for better generalization.
- **Error Handling and Optimization**: Robust error handling and performance improvements.

## Installation

Install the package using pip:
```bash
pip install musicgen_trainer
```

## Usage

### Import the Module
```python
from musicgen_trainer import MusicgenForConditionalGeneration
```

### Generate MIDI
```python
import torch

# Initialize the model
model = MusicgenForConditionalGeneration()

# Create a random input sequence
input_sequence = torch.randn(1, 10, 128)  # (batch_size, seq_len, input_dim)

# Generate a MIDI file
model.generate_midi(input_sequence, seq_len=100, output_path="output.mid", tempo=120, key="C")
```

### Save and Load Models
```python
# Save the model
model.save_model(model, path="musicgen_model.pth")

# Load the model
loaded_model = model.load_model(path="musicgen_model.pth")
```

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request with your changes.

## License

This project is licensed under the MIT License. See the LICENSE file for details.

## Support

For issues or questions, please contact [Your Email] or open an issue on the [GitHub repository](https://github.com/yourusername/musicgen_trainer).
liman 0.1.0a4
Liman AgentOps
Requires Python: >=3.10

# Liman

High-level AgentOps package for building and running conversational AI agents using YAML manifests and node-based workflows.

## Purpose

**liman** is the main entry point package that provides production-ready tools for orchestrating multi-turn AI conversations. Built on top of [liman_core](https://github.com/gurobokum/liman/tree/main/python/packages/liman_core), it offers:

- **Agent orchestration**: Manages complex conversational flows with state persistence
- **Executor engine**: Handles sequential and parallel node execution workflows
- **YAML-based configuration**: Load and compose agent definitions from declarative manifests
- **State management**: Built-in persistence for conversation history and execution state
- **Error handling**: Comprehensive logging and recovery mechanisms

## Installation

Requires Python 3.10+

```bash
# with pip
pip install liman
# with uv
uv pip install liman
# with poetry
poetry add liman
```

## Quick Start

**Step 1**: Create a directory for your agent specifications:

```bash
mkdir agents
```

**Step 2**: Create a YAML file for your agent node, e.g., `agents/llm.yaml`:

```yaml
# agents/llm.yaml
kind: LLMNode
name: assistant
description: A conversational AI assistant
prompts:
  system: You are a helpful assistant.
```

**Step 3**: Create a Python script to run the agent:

```python
from langchain_openai.chat_models import ChatOpenAI
from liman import Agent, Registry, load_specs_from_directory

llm = ChatOpenAI(model="gpt-4o")

# Create conversational agent
agent = Agent(
    "./agents",  # directory with YAML specs
    start_node="assistant"
    llm=llm,  # Langchain LLM instance
)

respones = agent.step("Hello! Can you help me with a math problem?")
print(response)
```

## Architecture

```
Agent → Executor → NodeActor → Node (from liman_core)
  ↓        ↓           ↓            ↓
Queue   Workflow   Execution   Specification
```

- **Agent**: Manages conversation queues and multi-turn interactions
- **Executor**: Orchestrates node execution with state persistence
- **State storage**: Handles conversation and execution state across sessions

## vs liman_core

| liman                      | liman_core                |
| -------------------------- | ------------------------- |
| High-level Agent class     | Low-level Node/NodeActor  |
| Multi-turn conversations   | Single node execution     |
| YAML configuration loading | Node specifications       |
| State persistence          | Stateless building blocks |
| Production error handling  | Core primitives           |

Use **liman** for building complete conversational agents, **liman_core** for low-level components that allow you to build your own orchestration.

## Development

```bash
# Run tests
poe test
# Type checking
poe mypy
# Linting
poe lint
# Format code
poe format
```