semvec/pypi-packages huggingface dataset:
bindle 0.0.3
My blanket stick.
Requires Python: >=3.8

# Bindle

[![PyPI - Version](https://img.shields.io/pypi/v/bindle.svg)](https://pypi.org/project/bindle)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bindle.svg)](https://pypi.org/project/bindle)

-----

## Table of Contents

- [Installation](#installation)

## Installation

```console
pip install bindle
```

## License

`bindle` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
treelyze 0.1.2
A CLI tool for analyzing directory structures and summarizing files
Requires Python: <4.0,>=3.10
Keywords: cli, directory, analysis, summarization

# Treelyze

Treelyze is a powerful CLI tool for analyzing directory structures and optionally summarizing file contents using Language Models (LLMs). It provides an easy-to-use interface for exploring and understanding complex directory hierarchies.

## Features

- Analyze directory structures with customizable depth
- Exclude specific directories from analysis
- Summarize file contents using LLMs (optional)
- Configurable settings for model and prompt customization
- Output results to file or console

## Installation

You can install Treelyze using pip:

```bash
pip install treelyze
```

## Usage

### Basic Usage

To analyze the current directory:

```bash
treelyze run
```

To analyze a specific directory:

```bash
treelyze run /path/to/directory
```

### Options

- `--max-depth, -d`: Set the maximum depth for directory traversal
- `--exclude, -e`: Specify directories to exclude (can be used multiple times)
- `--summarize, -s`: Enable file content summarization using LLM
- `--output, -o`: Specify an output file for the analysis results
- `--model`: Override the default language model for summarization
- `--prompt`: Override the default summarization prompt

### Examples

Analyze a directory with a maximum depth of 3, excluding 'node_modules':

```bash
treelyze run /path/to/directory --max-depth 3 --exclude node_modules
```

Analyze and summarize files, outputting results to a file:

```bash
treelyze run /path/to/directory --summarize --output results.txt
```

### Configuration

You can manage Treelyze configuration using the `config` subcommand:

```bash
# Show current configuration
treelyze config --show

# Set a configuration value
treelyze config --set model "gpt-3.5-turbo"
treelyze config --set prompt "Summarize this file concisely:"
```

**Note:** The configuration file is located at `~/.treelyze/config.yaml` in your home folder.

## Contributing

Contributions to Treelyze are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
SQLViaCode 0.1.2
A Python package to query SQL databases and manage backups.
Requires Python: >=3.6

### Database Query and Backup Script - Summary

This script provides the `get_query_from_db` function, designed to connect to a SQL Server database, execute a specified query, and optionally create a backup of a table as a CSV file.

#### Function Usage

- The `get_query_from_db(query, table_to_backup)` function accepts two parameters:
  - `query`: A SQL query string to execute on the database.
  - `table_to_backup`: The name of a table to back up to a CSV file. If you don't want to create a backup, set this parameter to `None`.

#### Setup Instructions

1. **Environment Variables**:
   - The script requires a `.env` file to load database credentials and connection details.
   - Required variables:
     ```plaintext
     USER=
     PASSWORD=
     HOST=
     NAME=
     DRIVER=ODBC+Driver+17+for+SQL+Server
     ```
     Leave `DB_DRIVER` unchanged, and fill in the other variables with your database details.

2. **Install Dependencies**:
   - Run the following command to install all required dependencies listed in `requirements.txt`:
     ```bash
     pip install -r requirements.txt
     ```

#### Example:
   ```python
   query = "SELECT * FROM your_table"
   result_df = get_query_from_db(query, "your_table_to_backup")
dstructslib 1.0.2
Data Structures Collections: BST and Linked Lists.
Requires Python: >=3.6

# DS Collections

## Overview

**DS Collections** is a Python package that provides efficient and easy-to-use implementations of fundamental data structures. It currently includes:

- **Singly Linked List**: A simple linked list where each node points to the next.
- **Doubly Linked List**: A more advanced linked list with both forward and backward traversal.
- **Binary Search Tree (BST)**: A binary tree for efficient searching, insertion, and deletion operations.

This package is designed for developers, students, and anyone learning about data structures or needing these implementations in their projects.

---

## Features

- **Singly Linked List**
  - Add, delete, and traverse nodes.
  - Efficient memory usage for linear data.

- **Doubly Linked List**
  - Supports bidirectional traversal.
  - Add or delete nodes at any position.

- **Binary Search Tree**
  - Allows duplicate or unique keys.
  - Includes functions for insertion, deletion, and traversal.

---

## Installation

You can install the package locally or through PyPI (if uploaded):

```bash
pip install dstructslib
pyrfc-read 1.0.2
Read data from SAP R/3 Systems
Requires Python: >=3.6

# pyrfc-read

<p align="center">
    <em>Query table data from SAP R/3 Systems</em>
</p>

[![PyPI Latest Release](https://img.shields.io/pypi/v/pyrfc-read.svg)](https://pypi.org/project/pyrfc-read/)
[![PyPI downloads](https://static.pepy.tech/badge/pyrfc-read)](https://pepy.tech/project/pyrfc-read)
[![License](https://img.shields.io/github/license/amarvin/pyrfc-read)](https://github.com/amarvin/pyrfc-read/blob/main/LICENSE)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
[![codecov](https://codecov.io/gh/amarvin/pyrfc-read/branch/main/graph/badge.svg)](https://codecov.io/gh/amarvin/pyrfc-read)

## Install

```
pip install pyrfc-read
```

### Prerequisites

SAP NW RFC SDK must be installed (https://support.sap.com/nwrfcsdk).

## Demo

```py
from pyrfc_read import Connection

# Define credentials to the SAP R/3 System
#  many combinations of key-values will work here, and these are just an example
#  https://help.sap.com/doc/saphelp_nw74/7.4.16/de-DE/48/b0ff6b792d356be10000000a421937/frameset.htm
credentials = dict(
    ashost="hostname",
    sysnr="system_number",
    client="client",
    user="user",
    passwd="password",
    lang="EN",
)

# Open connection to the SAP R/3 System
with Connection(**credentials) as conn:
    # Confirm connection active by having SAP echo a message
    message = "Hello world!"
    response = conn.echo(message)

    # Get number of entries in table
    table = "T001"
    entries = conn.number_entries(table)

    # Get table description
    #  in any supported language by SAP Language Code
    #  https://help.sap.com/doc/saphelp_nw73ehp1/7.31.19/en-US/c1/ae563cd2ad4f0ce10000000a11402f/content.htm?no_cache=true
    description = conn.table_description(table, language="E")

    # Search tables by description
    description = "data that I need"
    tables = conn.find_tables_by_description(description, language="E")

    # Get table metadata about its fields
    field_info = conn.field_info(table, descriptions=True, language="E")

    # Read table data, only for select fields, matching where conditions
    fields = [
        "BUKRS",  # Company code
        "BUTXT",  # Name of company
    ]
    wheres = [
        "MANDT = 100",  # Client 100
        ["BUKRS", "in", ["0001", "0002", "0003"]],  # Only company codes 1, 2 and 3
    ]
    data = conn.query(
        table,
        fields,  # optional, but requesting less fields reduces load on SAP
        wheres,  # optional
        field_info=field_info,  # optional, but makes it faster if you already it
        batch_rows=1000,  # optional, handles batching rows to not exceed SAP's output limit
        chunk_rows=100,  # optional, handles chunking long wheres conditions to not exceed SAP's input limit
    )
```

## License

This project is licensed under the terms of the MIT license.
parse-me 0.2.0
An AI-backed name parsing package for Middle-Eastern and Other languages.
Requires Python: >=3.9

# MEHDIE Arabic Name Parser

This is an AI-backed name parser that parses names into their constituent parts. The parser employs an Open-AI GPT Chat  
model that is prompted with explanations on how to parse names of the specific chosen language, script and sometimes
historical period. The GPT model is also given a langauge and script specific example. 
The response is parsed into a structured response by the phi.agent framework and some post-processing rules are applied 
to handle some of the common mistakes the agent makes.  

The parser was developed as part of the MEHDIE project- https://mehdie.org/. <img src="https://gitlab.com/m8417/hebrew-transliteration-service/-/raw/main/mehdie_logo.png" alt="the mehdie logo is a line-drawn M in several similar lines symbolizing the similarity and distincness of the middle-eastern languages" width="100"/>)

MEHDIE is funded by the Israel Ministry of Science and Technology [MOST](www.most.gov.il). <img src="https://gitlab.com/m8417/hebrew-transliteration-service/-/raw/main/menora.png" alt="The symbol of the state of Israel, a Menora with two olive branches on the sides." width="80"/>) 


## Usage
The parser can be used to parse a single name or a given tab-seperated file containing names. 

### Set up

1. Choose which language and script to parse from. Supported language-script combinations can be shown by running: `print(parse.get_supported_languages())`
2. Choose an AI model to use. The model string needs to be one of the valid models specified in the [OpenAI API](https://platform.openai.com/docs/models) or the [Anthropic API](https://docs.anthropic.com/en/docs/about-claude/models).
3. Set an environment variable for your chosen AI provider's API key (e.g. `export OPENAI_API_KEY=your-api-key` or `export ANTHROPIC_API_KEY=your-api-key`). 

### Parsing a single name

```
from parse_me.parse import parse_name

result = parse_name(name="Abū Ayyūb Sulaymān b. Yaḥyā b. Ǧabīrūl al-Qurṭubī", language="arL",
                    background_info="A fighter and a poet", model_name="gpt-o1-mini")
```

Use the `background_info` parameter to provide additional context that can help the parser understand the name better.
Use the `model_name` parameter to specify the AI model to use, e.g. `gpt-4o` or `claude-3-5-sonnet-latest`. 
This model should match the API key you have set up.

### Parsing a file with names

```
from parse_me.parse import parse_tsv

result_file = parse_tsv(tsv_file='/data/names.tsv', column_name='person_name', language='he', background_column_name='description',
              model_name='gpt-4o')
```

## Contributing

We invite users to contribute new prompts and examples for existing and new languages, scripts and historical periods. 
Just edit the parsing_prompts and open a pull request or open an issue with suggested additional post-processing rules 
or encountered mistakes the parser made.
cookiecutter_poetry_deepak 0.0.2
A Demo Project for Cookiecutter Poetry
Requires Python: <4.0,>=3.8

# cookiecutter-poetry

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

A Demo Project for Cookiecutter Poetry

-   **Github repository**: <https://github.com/DeepakPant93/cookiecutter-poetry/>
-   **Documentation** <https://DeepakPant93.github.io/cookiecutter-poetry/>

## Getting started with your project

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:DeepakPant93/cookiecutter-poetry.git
git push -u origin main
```

Finally, install the environment and the pre-commit hooks with

```bash
make install
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).

## Releasing a new version

-   Create an API Token on [PyPI](https://pypi.org/).
-   Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/DeepakPant93/cookiecutter-poetry/settings/secrets/actions/new).
-   Create a [new release](https://github.com/DeepakPant93/cookiecutter-poetry/releases/new) on Github.
-   Create a new tag in the form `*.*.*`.
-   For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
askpythia 1.3.3
AI Hallucination tool including basic validators
Requires Python: >=3.10

# wisecube-pythia

## As a library
You can install the project as a library from github
```commandline
pip install git+https://github.com/wisecubeai/wisecube-pythia
```
or if you don't have the git configure use the token
```
pip install git+https://<GIT_TOKEN>@github.com/wisecubeai/wisecube-pythia
```

**Also is required to have the `OPENAI_API_KEY` set as an env variable**

Usage
```python
from pythia.ai_hallucination import ask_pythia

ref = ["ref1", "ref1"]
resp = "response"
question = "question"

pythia_response = ask_pythia(input_reference=ref, input_response=resp, question=question
print(pythia_response)
```

## As a Rest API
### Docker build 
```
docker build -t wisecube-pythia .
```

### Docker run
```commandline
docker run -p 8085:8085 --name wiscube-pythia -e OPENAI_API_KEY=<KEY> public.ecr.aws/u9o1b9m6/wisecube-pythia:latest
```
azhacks 0.1.6
Add your description here
Requires Python: >=3.12

# Azhacks

Azhacks is a Python package that provides a collection of management utilities for handling containers, queues, storage resources, and tables.

## Features

- Container Management: Efficient container orchestration and lifecycle management
- Queue Management: Robust queue handling and processing capabilities
- Storage Resource Management: Flexible storage resource allocation and management
- Table Management: Comprehensive table operations and management utilities

## Installation

```bash
pip install azhacks
```

## Requirements

- Python >= 3.12

## Project Structure

```bash
src/azhacks/
├── container_manager.py     # Container management functionality
├── queue_manager.py        # Queue management operations
├── storage_resource_manager.py  # Storage resource handling
└── table_manager.py        # Table management utilities
```

## Usage

```python
from azhacks.container_manager import ContainerManager
from azhacks.queue_manager import QueueManager
from azhacks.storage_resource_manager import StorageResourceManager
from azhacks.table_manager import TableManager

# Initialize managers as needed for your use case, for example:
async with ContainerManager("container", "account", "api-key") as container_manager:
    # Use container_manager for container management operations
    pass
```

## License

This project is licensed under the terms included in the LICENSE file.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.