semvec/pypi-packages huggingface dataset:
bashi 1.1.7
Python Package made by Mhadhbi Issam .

# ibash


## Installation : 
```bash 
pip install bashi
```
## Quick start : 
```python 
from bashi import bash

result = bash("ls")
if result.code == 0 : 
    stdout = result.stdout 
    stderr = result.stderr

result2 = bash("not working command ")
```

<pre><span style="background-color:#26A269"><b> $ ls          </b></span>
main.py

<span style="background-color:#26A269"><b> $ not working command           </b></span><font color="#C01C28"><b> ==&gt; code 127</b></font>
<font color="#C01C28">/bin/sh: 1: not: not found)</font>
</pre>
llm-acuration 0.0.6
An LLM package made by Acuration
Requires Python: >=3.8

First version of Acuration's LLM library

Try it out
```
pip install llm-acuration
```

```
from llm_acuration.hello import hello
hello()
```
Prints "Hello, Acuration World!"

You can use help() on functions to know more about them

0.0.4
- added requirements.txt file

0.0.5
- just testing out how to automatically install dependencies
argilla-haystack 0.0.2
Argilla-Haystack Integration
Requires Python: >=3.8
Keywords: annotation,llm,monitoring

# Argilla-Haystack

Argilla is an open-source platform for data-centric LLM development. Integrates human and model feedback loops for continuous LLM refinement and oversight.

With Argilla's Python SDK and adaptable UI, you can create human and model-in-the-loop workflows for:

- Supervised fine-tuning
- Preference tuning (RLHF, DPO, RLAIF, and more)
- Small, specialized NLP models
- Scalable evaluation.

## Getting Started

You first need to install argilla and argilla-haystack as follows:

```bash
pip install argilla argilla-haystack["haystack-v1"]
```

You will need to an Argilla Server running to monitor the LLM. You can either install the server locally or have it on HuggingFace Spaces. For a complete guide on how to install and initialize the server, you can refer to the [Quickstart Guide](https://docs.argilla.io/en/latest/getting_started/quickstart_installation.html). 

## Usage

You can use your Haystack agent with Argilla with just a simple step. After the agent is created, we will need to call the handler to log the data into Argilla. 

Let us create a simple pipeline with a conversational agent. Also, we will use GPT3.5 from OpenAI as our LLM. For this, you will need a valid API key from OpenAI. You can have more info and get one via [this link](https://openai.com/blog/openai-api).

After you get your API key, let us import the key.

```python
import os
from getpass import getpass

openai_api_key = os.getenv("OPENAI_API_KEY", None) or getpass("Enter OpenAI API key:")
```

With the code snippet below, let us create the agent.

```python
from haystack.nodes import PromptNode
from haystack.agents.memory import ConversationSummaryMemory
from haystack.agents.conversational import ConversationalAgent

# Define the node with the model
prompt_node = PromptNode(
    model_name_or_path="gpt-3.5-turbo-instruct", api_key=openai_api_key, max_length=256, stop_words=["Human"]
)
summary_memory = ConversationSummaryMemory(prompt_node)
conversational_agent = ConversationalAgent(prompt_node=prompt_node, memory=summary_memory)
```

Let us import the ArgillaCallback and run it. Note that the dataset with the given name will be pulled from Argilla server. If the dataset does not exist, it will be created with the given name.

```python
from argilla_haystack import ArgillaCallback

api_key = "argilla.apikey"
api_url = "http://localhost:6900/"
dataset_name = "conversational_ai"

ArgillaCallback(agent=conversational_agent, dataset_name=dataset_name, api_url=api_url, api_key=api_key)
```

Now, let us run the agent to obtain a response. The prompt given and the response obtained will be logged in to Argilla server.

```python
conversational_agent.run("Tell me three most interesting things about Istanbul, Turkey")
```

![Alt text](docs/images/argilla-haystack-agent.png)

## Other Use Cases

Please refer to this [notebook](https://github.com/argilla-io/argilla-haystack/blob/feat/1-feature-create-argillacallback-for-haystack/docs/use_argilla_callback_in_haystack-v1.ipynb) for a more detailed example.
cvat-data-flow 0.1.0
A utility for working with CVAT data flow
Requires Python: >=3.8

# CVAT DATA FLOW

## New

- [x] Add support for export in YOLOv8 segmentation and detection formats (for segmentation *dataset_format = "yolo_seg"*)
- [x] Add support for installation via pip
- [x] Add support for downloading multiple tasks from different projects

## Overview

This utility facilitates the download of datasets from [CVAT](https://github.com/opencv/cvat), preparing them for training and testing purposes. Key features include:

- Downloading datasets from CVAT in any supported format.
- Merging multiple tasks to form a consolidated dataset.
- Randomly segmenting the dataset into training, validation, and testing subsets.

## Local Installation

Clone the repository:

```bash
git clone https://github.com/ai-iaguzhinskii/cvat_data_flow.git
```

Install the dependencies:

```bash
pip3 install -r requirements.txt
```

## Configuration

Edit the configuration as per your requirements in the [config_file](config.ini):

```ini
[CVAT]
URL = # URL of the CVAT server, e.g., http://localhost:8080
LOGIN = # CVAT user login, e.g., admin
PASS = # CVAT user password, e.g., admin

[DOWNLOAD]
TASKS_IDS = # Task IDs for downloading, e.g., [111, 222, 333]
PROJECTS_IDS = # Project IDs for downloading, e.g., [111, 222, 333]

[DATASET]
FORMAT = # Desired dataset format. Refer to CVAT documentation for options, e.g., coco
# For YOLOv8 segmentation and detection formats use "yolo_seg" and "yolo_det" respectively
SAVE_PATH = # Directory to save the downloaded datasets, e.g., /home/user/datasets
SPLIT = # Define random splits for the dataset, e.g., {"train": 0.8, "val": 0.1, "test": 0.1}

[OPTIONS]
ONLY_BUILD_DATASET = # Toggle to build dataset only if tasks are previously downloaded, e.g., True
LABELS_MAPPING = # Define label mappings, e.g., {"car": "vehicle", "person": "pedestrian"}
DEBUG = # Toggle debug mode, e.g., True
```

## Usage

To run the program:

```bash
python3 cvat_data_flow/main.py
```

Note: Ensure to replace placeholders in the configuration with actual values before executing.

## Installation via PIP

The utility can be installed via pip:

```bash
pip3 install cvat-data-flow
```

## Usage as a Python Package

The utility can also be used as a Python package. Here's an example:

```python
from cvat_data_flow import CVATDataFlow

cvat_data_flow = CVATDataFlow(
        url='http://cvat.example.com',
        login='username',
        password='password',
        save_path='/path/to/save/dataset',
        projects_ids=[1, 2, 3],
        only_build_dataset=False,
        dataset_format='coco',
        split=[('train', 0.7), ('val', 0.2), ('test', 0.1)],
        labels_mapping={'person': 'person', 'car': 'vehicle'}
    )

cvat_data_flow.download_data()
cvat_data_flow.build_dataset()
```

---

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.