semvec/pypi-packages huggingface dataset:
TextToVector 2025.5.180916
A package to convert text into embedding vectors using Hugging Face models.
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/TextToVector.svg)](https://badge.fury.io/py/TextToVector)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/TextToVector)](https://pepy.tech/project/TextToVector)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# TextToVector

`TextToVector` is a Python package designed to convert text into embedding vectors using Hugging Face models. This tool simplifies the process of generating embeddings for any given text, facilitating easy integration into NLP pipelines or machine learning models.

## Installation

To install `TextToVector`, you can use pip:

```bash
pip install TextToVector
```

## Usage

`TextToVector` is straightforward to use in your Python projects. Here's a quick example:

```python
from text_to_vector import TextToVector

t2v = TextToVector(model_name='bert-base-uncased')
text = "def hello_world():\n    print('Hello, world!')"
vector = t2v.text_to_embedding(text)
print("Generated Vector:", vector)
```

This package is especially useful for applications requiring text representations, such as semantic analysis, information retrieval, or machine learning models where text data needs to be converted into numerical form.

## Features

- Easy generation of embedding vectors from text.
- Utilizes state-of-the-art models from Hugging Face.
- Supports customization of model choices.
- Lightweight and easy to integrate.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/chigwell/TextToVector/issues).

## License

This project is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).
EmbedMan 2025.5.180914
A tool for managing embeddings for code analysis
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/embedman.svg)](https://badge.fury.io/py/embedman)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/embedman)](https://pepy.tech/project/embedman)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# EmbedMan

`EmbedMan` is a Python package designed to manage embeddings for code analysis efficiently. It facilitates the process of generating and retrieving embeddings from a specified directory of code files, utilizing the power of language models and embedding storage solutions.

## Installation

To install `EmbedMan`, you can use pip:

```bash
pip install embedman
```

## Usage

### As a Python Module

After installation, `EmbedMan` can be imported and used in your Python projects.

Example:

```python
from embed_man import EmbedManager

# Initialize the EmbedManager with desired parameters
embed_manager = EmbedManager(
    path="path/to/your/code/directory",
    glob_rule="**/*.py",
    use_cache=True
)

# Run the embedding process and get a retriever for querying embeddings
retriever = embed_manager.run()

# You can now use the retriever to query embeddings
```

### Configurable Parameters

`EmbedMan` allows various configurations to tailor the embedding process to your needs, including:

- `path`: The directory path to scan for documents.
- `glob_rule`: Glob pattern to match files within the directory.
- `suffixes`: List of file suffixes to include.
- `exclude`: List of patterns to exclude.
- `language`: Programming language of the documents.
- `parser_threshold`: Threshold for the parser to consider a document valid.
- `chunk_size`: Size of chunks to split documents into for embedding.
- `chunk_overlap`: Overlap between consecutive chunks.
- `cache_dir`: Directory path for caching embeddings.
- `namespace_cache`: Namespace for the cache to avoid collisions.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check [issues page](https://github.com/chigwell/embedman/issues).

## License

[MIT](https://choosealicense.com/licenses/mit/)
MistralGPTIntegration 2025.5.180912
Integration utility for Mistral AI API to provide GPT-based functionalities.
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/MistralGPTIntegration.svg)](https://badge.fury.io/py/MistralGPTIntegration)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/MistralGPTIntegration)](https://pepy.tech/project/MistralGPTIntegration)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# MistralGPTIntegration

`MistralGPTIntegration` is a Python package designed to provide GPT-based functionalities using the Mistral AI API. It enables users to quickly obtain comprehensive, context-aware responses from the model.

## Installation

To install `MistralGPTIntegration`, you can use pip:

```bash
pip install MistralGPTIntegration
```

## Usage

After installation, `MistralGPTIntegration` can be used in your Python scripts.

Example:

```python
from mistralgptintegration import MistralGPTIntegration

api_key = "<your_api_key>"
mistral = MistralGPTIntegration(api_key)
prompt = "Once upon a time"
response = mistral.query_gpt(prompt)
print(response)
```

- `api_key`: Your Mistral API key.
- `model_name`: The name of the Mistral model to use. Defaults to `mistral-tiny`.
- `temperature`: The temperature to use for the model. Defaults to `0.1`.
- `top_p`: The top_p to use for the model. Defaults to `1.0`.
- `max_tokens`: The maximum number of tokens to generate. Defaults to `150`.

## Customizing Your Queries

You can customize the behavior of `MistralGPTIntegration` by adjusting the parameters, such as the temperature, top_p, max_tokens, etc., to fit the specific needs of your queries or to tweak the behavior of the Mistral model.

## Output Example

When you query the model, it processes your prompt and returns a response. Here is an example of the output:

```json
{
  "id": "63213d34c61f4d96b893d7b1afc2b893",
  "object": "chat.completion",
  "created": 1706372087,
  "model": "mistral-small",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "some text"
      },
      "finish_reason": "stop",
      "index": 0
    }
  ],
  "usage": {
    "prompt_tokens": 318,
    "total_tokens": 622,
    "completion_tokens": 304
  }
}
```

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check [issues page](https://github.com/chigwell/MistralGPTIntegration/issues).

## License

[MIT](https://choosealicense.com/licenses/mit/)
get-gitlab-issues 2025.5.180909
A Python package for extracting issues from GitLab repositories.
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/get-gitlab-issues.svg)](https://badge.fury.io/py/get-gitlab-issues)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/get-gitlab-issues)](https://pepy.tech/project/get-gitlab-issues)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# Get GitLab Issues

`Get GitLab Issues` is a Python package designed to facilitate the extraction and management of issues from GitLab repositories. This tool is essential for developers looking to streamline their issue tracking processes directly through Python scripts.

## Installation

To install `Get GitLab Issues`, you can use pip:

```bash
pip install get-gitlab-issues
```

## Usage

`Get GitLab Issues` provides a straightforward API to interact with GitLab issues. Below is an example of how to use the package to retrieve issues and check user access:

### Example

```python
from get_gitlab_issues import check_access, get_gitlab_issues, get_gitlab_issue

# Check user access
if check_access('YOUR_PRIVATE_TOKEN', 'https://gitlab.example.com'):
    print("Access verified")

# Fetch issues for a specific group
issues = get_gitlab_issues('YOUR_PRIVATE_TOKEN', 'https://gitlab.example.com', '123456')
for issue in issues:
    print(issue.title, issue.description)

# Fetch a specific issue
issue_detail = get_gitlab_issue('YOUR_PRIVATE_TOKEN', 'https://gitlab.example.com', '123456', '1')
print(issue_detail.title, issue_detail.description)
```

## Functions

- `check_access(token, url)`: Checks if the provided token has access to the GitLab API.
- `get_gitlab_issues(token, url, group_id, labels=None, iteration_id=None)`: Retrieves a list of issues from a specified group.
- `get_gitlab_issue(token, url, project_id, issue_id)`: Retrieves details for a specific issue.

## Features

- Simple installation and easy usage.
- Efficient access to GitLab issues through the API.
- Ability to check user access and retrieve specific issues or lists of issues.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/chigwell/get-gitlab-issues/issues).

## License

This project is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).
pytimeir 0.3
Get events and holidays from time.ir
Requires Python: >=3.6

# pytimeir

[![Python ver](https://img.shields.io/pypi/pyversions/pytimeir.svg)](https://pypi.python.org/pypi/pytimeir)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

A simple package to get events and holidays from [time.ir](https://www.time.ir/)

## Getting Started

Install the package with:

```
pip install pytimeir
```

## Usage

```python
import pytimeir

# get holidays for a year
df = pytimeir.get_holidays(1401)

# get holidays for a range of years
df = pytimeir.get_holidays(1390, 1410)

# get events for a year
df = pytimeir.get_events(1401)

# get events for a range of years
df = pytimeir.get_events(1390, 1410)
```
TaskFeasibilityAnalyzer 2025.5.180905
A Python package to determine the feasibility of coding tasks using GPT-3.
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/TaskFeasibilityAnalyzer.svg)](https://badge.fury.io/py/TaskFeasibilityAnalyzer)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/taskfeasibilityanalyzer)](https://pepy.tech/project/taskfeasibilityanalyzer)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# TaskFeasibilityAnalyzer

`TaskFeasibilityAnalyzer` is a Python package designed to determine the feasibility of coding tasks using GPT-3. It provides a probability score indicating whether a task can be completed successfully based on the project's structure and technology stack.

## Installation

To install `TaskFeasibilityAnalyzer`, you can use pip:

```bash
pip install TaskFeasibilityAnalyzer
```

## Usage

### As a Python Module

`TaskFeasibilityAnalyzer` can be used as a Python module in your scripts.

#### Analyzing a Task's Feasibility

```python
import json
from taskfeasibilityanalyzer import TaskFeasibilityAnalyzer

# Initialize the analyzer with the target directory and your OpenAI API key
analyzer = TaskFeasibilityAnalyzer('/path/to/your/project', 'your-openai-api-key')

# Analyze a task and get a probability score
task_description = "Refactor the database schema to improve performance."
probability = analyzer.analyze_task(task_description)
result = json.loads(probability)
print(f"The probability that the task can be completed successfully is {result:.2f}")
```

## Features

- **Integrates with GPT-3**: Leverages the power of GPT-3 to analyze the complexity and requirements of coding tasks.
- **Project Structure Analysis**: Uses ProjectStructoR to understand the project's structure and technology stack.
- **Probability Score**: Provides a numerical estimate indicating the feasibility of completing a task.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/chigwell/TaskFeasibilityAnalyzer/issues).

## License

This project is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).
FileChunkCRUD 2025.5.180903
Python package for CRUD operations on large files in chunks.

[![PyPI version](https://badge.fury.io/py/FileChunkCRUD.svg)](https://badge.fury.io/py/FileChunkCRUD)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/filechunkcrud)](https://pepy.tech/project/filechunkcrud)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# FileChunkCRUD

`FileChunkCRUD` is a Python tool designed for Create, Read, Update, and Delete operations on files, especially large files that need to be processed in chunks to fit into memory constraints.

## Installation

To install `FileChunkCRUD`, you can use pip:

```bash
pip install FileChunkCRUD
```

## Usage

### As a Python Module

`FileChunkCRUD` can be used as a Python module in your scripts for handling large file operations.

Example:

```python
from filechunkcrud import FileHandler

file_path = '/path/to/your/largefile.txt'

# Initialize the file handler with the target file path
file_handler = FileHandler(file_path)

# Example of reading file in chunks
for chunk in file_handler.read_chunks(chunk_size=1024):  # chunk_size in bytes
    print(chunk)
...
```

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check [issues page](https://github.com/chigwell/FileChunkCRUD/issues).

## License


[MIT](https://choosealicense.com/licenses/mit/)
shamir-ss 0.2.3
Shamir's Secret Sharing implementation using Cython
Requires Python: >=3.9
Keywords: cryptography, shamir, secret sharing

![Tests](https://github.com/Team-Hype/shamir-secret-sharing/actions/workflows/package-test.yaml/badge.svg)
![PYPI](https://img.shields.io/pypi/v/shamir_ss.svg)
![versions](https://img.shields.io/pypi/pyversions/shamir_ss.svg)

# Shamir Secret Sharing (SSS)

Secure cryptographic implementation of Shamir's Secret Sharing scheme for splitting secrets into multiple shares. Designed for both short secrets and large text/data with automatic chunking.

## Features

- 🔒 Cryptographic security using Mersenne prime modulus (2¹²⁷-1)
- 📦 CLI interface and Python API
- ✨ Automatic chunking for large secrets
- 🚀 Cython-optimized core implementation
- ✅ Hash-based secret integrity verification

## Installation

```bash
pip install shamir_ss
```
## Development

For developement see following [guide](development.md)

## Python API

### Example
```python
from shamir_ss import generate_text_shares, reconstruct_text_secret

def main():
    secret = "My top secret"

    shares = generate_text_shares(secret, 3, 5)

    reconstructed = reconstruct_text_secret(shares[:3])
    print(reconstructed)

if __name__ == "__main__":
    main()

```

## CLI Application
### Features

 - 🔐 Interactive secret input with hidden typing
 - 📁 Multiple input formats (files/directories/text)
 - 🛡️ SHA-256 hash verification
 - 🔄 Automatic share validation

### Usage
```bash
python -m shamir_ss <command> <...args>
```
### Command list
```bash
shamir_ss --help         # Show all commands
shamir_ss split --help   # Split command help
shamir_ss combine --help # Combine command help
shamir_ss help           # Detailed usage examples
```

### Examples

```bash
python -m shamir_ss split \
  --secret "My top secret" \
  -t 3 -n 5 \
  --output shares
```
> Split secret to 5 shares with treshold 3 and put output to shares dir


```bash
python -m shamir_ss combine \
  -i shares
```
> Reconstruct secret from shares dir w/o hash validation (will be prompted interactively)


```bash
shamir_ss combine --text
```
> Reconstruct secret using interactive mode
ProjectStructoR 2025.5.180959
A tool for detecting project structure and technology stack with the help of GPT.

[![PyPI version](https://badge.fury.io/py/ProjectStructoR.svg)](https://badge.fury.io/py/ProjectStructoR)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/projectstructor)](https://pepy.tech/project/projectstructor)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# ProjectStructoR

`ProjectStructoR` is a Python tool designed to analyze directories and detect the project structure and technology stack used in the files. It leverages GPT from OpenAI to provide a comprehensive analysis including the count of files, lines of code, and the likely technologies present.

## Installation

To install `ProjectStructoR`, you can use pip:

```bash
pip install ProjectStructoR
```

## Usage

### As a Python Module

ProjectStructoR can be used as a Python module in your scripts.

Example:

```python
from projectstructor.detector import ProjectStructureDetector

# Initialize the detector with the target directory and your OpenAI API key
detector = ProjectStructureDetector('/path/to/your/project', 'your-openai-api-key')

# Detect the structure of the project
print(detector.detect_structure(ignore_gitignore=True))

# Detect the languages used in the project
print(detector.detect_languages())

# Analyze with GPT and print the JSON result
chat_completion = detector.analyze_with_gpt()
content = chat_completion.choices[0].message.content
result = json.loads(content)
print(json.dumps(result, indent=2))
```

### As a Command Line Tool

Currently, `ProjectStructoR` is intended to be used as a module in Python scripts. If there's enough interest, command line functionality may be added in future versions.

## Output Example

When you run `ProjectStructoR`, it outputs the structure of the project directory and a report with the detected languages and technologies. Here is an example output:

```
detected structure: 
project/
|-- main.py
|-- utils/
|   |-- __init__.py
|   |-- helper.py

detected languages and technologies: 
Python files: 3, lines of code: 120
JavaScript files: 1, lines of code: 45
```

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check [issues page](https://github.com/chigwell/projectstructor/issues).

## License

[MIT](https://choosealicense.com/licenses/mit/)
db-fds 0.3.1
Computations and Utility Functions for Database/Relation Functional Dependencies
Requires Python: >=3.0
Keywords: database, dbms, relations, functional dependency, closure, education, design

# DB-FDs

[![CodeQL](https://github.com/mmaimer33/DB-FDs/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/mmaimer33/DB-FDs/actions/workflows/github-code-scanning/codeql)

DB-FDs is a simple package containing utility functions to work with [**Functional Dependencies**](https://en.wikipedia.org/wiki/Functional_dependency) for Database design.

## Installation

You can install the package from [PyPI](https://pypi.org/project/db-fds/) using [pip](https://pypi.org/project/pip/):

    python -m pip install db-fds

or simply,

    pip install db-fds

Note: If your system does not use Python 3 by default, you may need to replace the command with `python3` or `pip3`, respectively.

The package is supported on Python 3.0 and above.

## How to use

After installation, import it into a Python program with

```py
from db_fds import fdfuncs
```

and use it like

```py
fdfuncs.Symbol("")
```

or

```py
from db_fds.fdfuncs import *

Symbol("")
```

### Classes

The package comes with 2 classes to create objects to work with: `Symbol` and `FunctionalDependency`. Use `Symbol` to represent an attribute in a relation, and create `FunctionalDependency` objects between 2 or more `Symbol`s. See the class and constructor docstrings for details.

## Documentation

Read the documentation in [one place](https://db-fds.readthedocs.io/en/latest/) to see the available functionality.

## Planned future additions

- BCNF and 3NF checks
- Normalization functions
- Checking for lossless decompositions

## How to Contribute

Fork the repository from [https://github.com/mmaimer33/DB-FDs](https://github.com/mmaimer33/DB-FDs) and submit a pull request. Also read the [Code of Conduct](CODE_OF_CONDUCT.md).
TeddyCloudStarter 0.6.3
The wizard for setting up TeddyCloud with Docker
Requires Python: >=3.6

# TeddyCloudStarter

[![Python 3.6+](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

A user-friendly wizard for setting up TeddyCloud deployments with Docker.

## ALPHA - RELEASE

WARNING - Very early development stage
Keep in mind that this project by far is not finished yet.
But it should bring you the concept of how it will work. 

Soon™ 

## 📋 Requirements

- Python 3.6 or newer
- Docker and Docker Compose
- Internet connection (for first-time setup and updates)

## 🚀 Installation

### Using pip

```bash
pip install TeddyCloudStarter
```

### From source

```bash
git clone https://github.com/Quentendo64/TeddyCloudStarter.git
cd TeddyCloudStarter
pip install -e .
```

## 💻 Usage

### Starting the wizard

```bash
TeddyCloudStarter
```

The wizard will guide you through the setup process with an interactive interface.


## 👏 Special Mentions

Special thanks to:

- [henryk](https://forum.revvox.de/u/henryk/) from Revoxx Forum - For extensive testing and heroic support during development

## 🤝 Contributing

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

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## 📄 License

This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.