semvec/pypi-packages huggingface dataset:
BootcampDIO-my-image-processing 0.0.1
Image processing package using Skimage
Requires Python: >=3.5

# BootcampDIO_my_image_processing

Description. 
The package package_name is used to:
	Processing:
		- Histogram 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 BootcampDIO_my_image_processing

```bash
pip install BootcampDIO_my_image_processing
```

## Author
Vitor

## License
[MIT](https://choosealicense.com/licenses/mit/)
kiwi-json 0.10.1
DRY JSON encoder.

# Kiwi JSON

![Kiwi JSON Logo](logo.jpg "Kiwi JSON")

# Purpose

At the time of creating this lib, there were (at least) three implementation of `default_encoder()`
 copy-pasted from one place, evolving its own way and about to being copy-pasted further.
 If you have read the story about AI and paperclips, you have an idea where this would lead us to.

To prevent this from happening, this library should unify all the implementation, and provide reusable
 implementation of the JSON encoding.

# Installation

Add `kiwi-json` into your requirements.in file

```
kiwi-json
```

# Usage

If you use your own JSON encoder as a class, use `default_encoder()` in there.

```python
import simplejson
from kw.json import default_encoder, mask_dict

class OurJSONEncoder(simplejson.JSONEncoder):

    def default(self, obj):
        return default_encoder(obj, mask_dict)
```

`kiwi-json` provides a simple implementation for masking dictionary values with `kw.json.mask_dict`. 
Or you can create a masking function for it by yourself. It supports customizing placeholder, blacklist and whitelist:

```python
from kw.json import mask_dict_factory

mask_dict = mask_dict_factory(placeholder='0_0', blacklist={'secret'}, whitelist={'not-so-secret'})
```

If you want to use `json.dumps` directly, you can do it the following way:

```python
import simplejson
from kw.json import default_encoder

dumps = partial(simplejson.dumps, default=default_encoder)
```

If you have `simplejson` installed, you can use Decimal as JSON `number` type:
```python
from decimal import Decimal
from kw.json import dumps, loads

assert dumps({"num": Decimal("1.234")}, use_decimal=True) == '{"num": 1.234}'
assert loads('{"num": 1.234}', use_decimal=True) == {"num": Decimal("1.234")}
```

Flask-based application could utilize the extension:

```python
from kw.json.flask import JSONExtension


def create_app():
    ...
    JSONExtension(app)
    ...
```

Extension will install an encoder to given app.

If you want to make sure that the encoder dumps classes, you can use the `raw_encoder`:

```python
from kw.json import raw_encoder, dumps

dumps(data, default=raw_encoder)
```

To dump dates and datetimes as unix time, use `date_as_unix_time=True`:

```python
import arrow
from datetime import datetime
from kw.json import dumps

dumps({1: datetime.now(), 2: arrow.now()}, date_as_unix_time=True)
```

If you want to combine the powers of `date_as_unix_time` and `raw_encoder`,
you can create your own encoder using partial:

```python
from kw.json import dumps, raw_encoder
from functools import partial

my_encoder = partial(raw_encoder, date_as_unix_time=True)
dumps(obj, default=my_encoder)
```

# Running tests

To run the tests we use tox. Before you can run the tests please make sure you have postgres database running and the DATABASE_URI env variable set

```bash
export DATABASE_URI='postgres://[username]:[password]@[host]:[port]/[database]'
```

Once you have this set up just execute:

```
tox
```
graphs-Dennis 0.0.4
A small example package
Requires Python: >=3.7

# Homework_4

URL for GitHub repository: https://github.com/2545046941/Homework_4

# graghs_Dennis

This package implements Dijkstra's algorithm.

# Installation 

You can install the package using : 

pip install git+https://github.com/2545046941/Homework_4.git

pip3 install git+https://github.com/2545046941/Homework_4.git

# Run Dijkstra's algorithm

python test.py - path-to-graph-file 

Example: python test.py example1.txt
proitav-api-wrappers 1.3.3
API Wrapper for ProITAV Products
Requires Python: >=3.6

# ProITAV API Wrappers

A collection of API wrappers for ProITAV products.

## Installation

You can install this package directly from PyPI:

```bash
pip install proitav-api-wrappers
```

For the latest development version, you can install directly from GitHub:

```bash
pip install git+https://github.com/yourusername/proitav-api-wrappers.git
```

## Usage

Here's an example of how to import and use a wrapper:

```python
from proitav_api_wrappers import IP5100

# Create an instance of the IP5100 wrapper
ip5100 = IP5100('192.168.1.100')

# Use the wrapper methods
ip5100.connect()
ip5100.get_device_info()
```

## Available Wrappers

- IP5100
- CAM600
- AMP120
- SW0401_N081_000
- MV0401_H2H4K60
- SC010
- SC009
- MS0402_N011
- FSC640
- (Add other wrappers as needed)

## Development

To set up the project for development:

1. Clone the repository:

   ```bash
   git clone https://github.com/JFaulk1434/proitav-api-wrappers.git
   cd proitav-api-wrappers
   ```

2. Create a virtual environment and activate it:

   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   ```

3. Install the package in editable mode with development dependencies:

   ```bash
   pip install -e .[dev]
   ```

## License

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

## Support

If you encounter any problems or have any questions, please open an issue on the GitHub repository.
italian-translator 0.2.0
A command-line tool for translating Italian words using Reverso Context.
Requires Python: >=3.6

# Italian Translator

**Italian Translator** is a command-line tool for translating Italian sentences and displaying examples using Reverso Context.

## Features

- Translate Italian sentences to English (default) or any specified language.
- Translate from a specified language to Italian using the `--reverse` option.
- Display a specified number of example sentences using the `--examples` option.
- Easy-to-use command-line interface with colored output.

## Installation

### Step 1: Download and Install Python

If you don't have Python installed, you can download it from the official website: [python.org](https://www.python.org/downloads/). Follow the instructions for your operating system to install Python.


### Step 2: Install the Package

You can install the package using `pip`:

```sh
pip install italian-translator
```

## Usage

```sh
italian-translator <sentence>
ita <sentence>
```

## Options

- `--reverse`, `-R`: Translate from a specified language to Italian.
- `--language`, `-L`: Specify the language to translate to (default: English).
- `--examples`, `-E`: Display a specified number of example sentences (default: 3).
- `--help`, `-h`: Display the help message.
- `--version`, `-v`: Show the version of the package.

## Examples

#### Translate an Italian sentence to English:
```sh
italian-translator "Ciao, come stai?"
ita il gatto
```
#### Translate an English sentence to Italian:
```sh
italian-translator --reverse "Hello, how are you?"
ita -R the cat
```
#### Translate an Italian sentence to French
```sh
italian-translator --language french "Ciao, come stai?"
ita -L french il gatto
```
#### Display 5 examples sentences:
```sh
italian-translator --examples 5 "Ciao, come stai"
ita -E 5 il gatto
```

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Author
- seafood - [GitHub](https://github.com/seafoodd) | [Telegram](https://t.me/seafudd)
Dennislib 0.0.3
A small example package
Requires Python: >=3.7

# Homework_4

URL for GitHub repository: https://github.com/2545046941/Homework_4

# graghs_Dennis

This package implements Dijkstra's algorithm.

# Installation 

You can install the package using : 

pip install git+https://github.com/2545046941/Homework_4.git

pip3 install git+https://github.com/2545046941/Homework_4.git

# Run Dijkstra's algorithm

python test.py - path-to-graph-file 

Example: python test.py example1.txt
ai-git-cli 0.1.6
An AI-powered Git commit message generator and manager.
Requires Python: >=3.7

# AI-Git-CLI Tool Documentation

## Introduction

The AI-Git-CLI Tool assists developers in creating structured and meaningful Git commit messages using artificial intelligence. It analyzes unstaged changes, groups them logically, generates descriptive commit messages, and automates the commit process.

## Installation

Install the tool via PyPi:

```bash
pip install ai-git-cli
```

## Custom Instructions During Commit

The `AI-Git-CLI` tool now allows you to provide custom instructions or prompts during the commit process. This feature enables the AI to incorporate your specific feedback, resulting in more tailored commit messages and logically grouped changes.

### How to Use

1. **Initiate Commit:**
   Run the commit command as usual:
   ```bash
   ai-git-cli commit [--config configs/config.yaml]
   ```
2. **Provide Custom Instructions:**
   During the commit process, you'll be prompted:
   ```
   Do you want to add any custom instructions for the AI? [y/n]: y
   Enter your custom instructions: Focus on summarizing new features and bug fixes clearly.
   ```
3. **AI-Enhanced Commit:**
   The AI will generate commit messages and group changes based on your provided instructions, ensuring that the commits align with your specific preferences and project needs.

### Benefits

- **Personalized Commit Messages:** Tailor commit messages to reflect the nuances of your project.
- **Improved Change Grouping:** Logical grouping of changes based on your instructions enhances codebase maintainability.
- **Enhanced Workflow:** Integrates seamlessly into your existing Git workflow, providing AI assistance without disrupting your development process.

### Example Interaction

```
ai-git-cli commit --config configs/config.yaml
Unstaged changes:
┏━━━━━━━━━━━━━━━┓
┃ README.md      ┃
┣━━━━━━━━━━━━━━━┫
┃ ...diff details... ┃
┗━━━━━━━━━━━━━━━┛
Do you want to add any custom instructions for the AI? [y/n]: y
Enter your custom instructions: Emphasize performance improvements and code refactoring in the commit messages.
Analyzing and grouping changes...
Generating commit messages...
Proposed Commits
┏━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Group ┃ Files         ┃ Commit Message             ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ 1     │ README.md     │ refactor: Improved documentation clarity. │
│ 2     │ app.py        │ feat: Enhanced performance in data processing. │
└───────┴───────────────┴─────────────────────────────┘
Commit for files: README.md
Suggested Message: refactor: Improved documentation clarity.
Choose action [accept/edit/skip]: accept
Commit for files: app.py
Suggested Message: feat: Enhanced performance in data processing.
Choose action [accept/edit/skip]: accept
Proceed with these commits? [y/n]: y
Commits created successfully.
Do you want to amend the commit history? [y/n]: n
```

This feature empowers you to guide the AI, ensuring that the generated commits are aligned with your project's specific requirements and your personal or team preferences.
djangordf 0.1.1
A RDF library for Django models
Requires Python: >=3.6

# Djangordf

**Djangordf** is a powerful Django library designed to manage RDF (Resource Description Framework) data directly from Django models. It provides full **CRUD functionality** for RDF data, allowing developers to easily create, read, update, and delete RDF triples. The library also supports **ontology creation** and **automatic synchronization** with external triple stores, making it a perfect solution for building semantically enriched web applications.

## Features

- Full **CRUD support** for RDF data
- **Ontology management** and custom RDF mappings
- **Automatic syncing** with external triple stores (e.g., RDF4J, Blazegraph)
- **SPARQL support** for querying RDF data
- Integration of **external RDF graphs** as alternative data sources
- Easy setup and usage within Django projects

## Installation

To install Djangordf, run the following command:

```bash
pip install djangordf
```

## Usage

Add `djangordf` to your Django project's `INSTALLED_APPS`.
Define RDF mappings for your Django models using the provided admin interface.
Use the API to interact with RDF triples or integrate them into your application.

## License

This project is licensed under the MIT License.
edlio 0.2.1
Module to work with data in an Experiment Directory Layout (EDL) structure
Requires Python: >=3.10

# EDL - Experiment Directory Layout

[![QA](https://github.com/bothlab/edlio/actions/workflows/python-qa.yml/badge.svg)](https://github.com/bothlab/edlio/actions/workflows/python-qa.yml)

This repository contains specifications for the "Experiment Directory Layout" (EDL) storage layout as
used by the [Syntalos](https://github.com/bothlab/syntalos) data acquisition tool.

It also contains a Python module, `edlio`, to easily load and save data in an EDL structure
for simplified raw experiment data management.

Check out the [online documentation](https://edl.readthedocs.io/latest/) to learn more about this project!
GitAdmin 0.1.2
CLI tool for quick GitHub repository management and viewing.
Requires Python: >3.6

# # GitAdmin

A Python command-line tool for managing GitHub repositories. This tool allows users to list repositories, manage visibility, and retrieve issue summaries from their GitHub account.

## Features

- **List Repositories**: Retrieve a list of your GitHub repositories, including their visibility status.
- **Manage Repository Visibility**: Change the visibility of your repositories (e.g., from public to private).
- **Get Issue Summaries**: Summarize open issues across your repositories.

## Installation

You can install the tool using `pip` once it is distributed:

```bash
pip install GitAdmin
```

## Setup
Before using the tool, run the setup command to configure your GitHub username and token
```bash
GitAdmin setup
```
This command will:
- prompt for your github token (repo is the only access it needs) and your username
- Store this within a local yaml file

## Usage
### list
```bash
GitAdmin list
```
returns a list of your repositories and their visibility
### visibility
```bash
GitAdmin visibility --repo <repositoryname> --visibility <public|private>
```
use to change visibility of given repo
### issues
```bash
GitAdmin issues --repo <repository name>
```
Fetches issues in given repository
ehrimage 0.0.dev1
Data Science Toolkit for Healthcare Images
Requires Python: >=3.11

# EHR: Data Science Toolkit for Healthcare Images

## Goal

Data science toolkit for clinical images.

## Setup Dev Environment

```terminal
conda create -n ehrimage python=3.12 -y
conda activate ehrimage
pip install uv  # first time only
make tools
```

## References

* Others
  * https://realpython.com/pypi-publish-python-package/
ehrnote 0.0.dev1
Data Science Toolkit for Healthcare Note
Requires Python: >=3.11

# EHR: Data Science Toolkit for Healthcare Note

## Goal

Data science toolkit for clinical notes.

## Setup Dev Environment

```terminal
conda create -n ehrnote python=3.12 -y
conda activate ehrnote
pip install uv  # first time only
make tools
```

## References

* Others
  * https://realpython.com/pypi-publish-python-package/
mumbleice 1.5.0
Mumble bot for streaming to Icecast
Requires Python: >=3.9
Keywords: mumble audio icecast streaming

# MumbleIce

This is a mumble bot for streaming audio from a Mumble room to Icecast.

# Installing

## Production (Docker)

The Docker image is recommended for running in production. The configuration
file can be mounted to `/mumbleice.yml` or configuration can be done using
environment variables. The file location can be changed with the
`MUMBLEICE_CONFIG_FILE` environment variable.

All configuration options can be set using environment variables:

```bash
docker run -e MUMBLE_SERVER=mumble.server bitcast/mumbleice:dev
```

### Environment Variables

- **MUMBLE_SERVER**: The Mumble server to connect to.
- **MUMBLE_PORT**: The port which the Mumble server uses. Defaults to `64738`.
- **MUMBLE_USERNAME**: The username for the bot on Mumble. Defaults to
  `live-streamer`.
- **MUMBLE_PASSWORD**: The server password.
- **MUMBLE_CHANNEL**: The Mumble channel to join. Defaults to `Root`.
- **MUMBLE_COMMAND_PREFIX**: The command prefix that identifies commands to the
  bot. Defaults to `!`.
- **MUMBLE_MAX_SILENCE**: The number of seconds of silence in Mumble required
  before the Icecast stream is disconnected. A value less than 0 implies that
  the connection will never be disconnected. Defaults to `30`.
- **ICECAST_SERVER**: The Icecast server to connect to.
- **ICECAST_PORT**: The port which the Icecast server uses. Defaults to `8000`.
- **ICECAST_USERNAME**: The username to authenticate against Icecast with.
  Defaults to `source`.
- **ICECAST_PASSWORD**: The password to authenticate against Icecast with.
  Defaults to `hackme`.
- **ICECAST_MOUNT_POINT**: The mount point to use for streaming audio. Defaults
  to `/mumble`.
- **ICECAST_AUTOCONNECT**: Automatically start streaming to Icecast once it is
  connected to Mumble. Defaults to `false`.

## Development

Mumbleice requires Python 3.9 or later.

```bash
sudo apt install python3-dev python3-pip libopus0 virtualenv pre-commit
virtualenv -p python3 pyenv
pyenv/bin/pip install -e .
pre-commit install
cp mumbleice.yml.example mumbleice.yml
# Configure MumbleIce to connect to your mumble and Icecast servers
pyenv/bin/mumbleice -c mumbleice.yml
```
genie-cli 0.1.0a3
A CLI tool from Valory to interact with the Genie service to generate Olas autonomous services from natural language
Requires Python: <4.0,>=3.11

# Genie CLI

Genie CLI is a command-line tool designed to interact with [Valory's Genie service](https://www.valory.xyz/post/propel-genie) to generate [Olas autonomous services](https://docs.autonolas.network/open-autonomy/get_started/what_is_an_agent_service/) using natural language. This tool leverages various libraries to provide a seamless experience for developers.

## Genie Signup Process
Please signup on this link to be added to the waitlist to get access credentials to run genie cli. [Valory's Genie Signup](https://www.valory.xyz/propel-genie).

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Project Structure](#project-structure)
- [License](#license)

## Installation

To install the Genie CLI, you need to have Python 3.9 or higher. You can install the dependencies using the following command:

```sh
pipx install genie-cli
pipx ensurepath
```

## Usage

To use the Genie CLI, you can run the following command:

```sh
genie
```

This will start the CLI and you can follow the prompts to generate AEA agents.

## Project Structure

The project is organized as follows:

```
genie-cli/
├── src/
│   ├── genie_cli/
│   │   ├── prompts/
│   │   │   └── behaviour_prompts.py
│   │   ├── widgets/
│   │   │   ├── prompt_input.py
│   │   │   └── chatbox.py
│   │   └── __main__.py
├── pyproject.toml
├── README.md
└── .gitignore
```

### Key Files

- **`pyproject.toml`**: Contains project metadata and dependencies.
- **`src/genie_cli/prompts/behaviour_prompts.py`**: Contains prompt templates for generating behavior plans.
- **`src/genie_cli/widgets/prompt_input.py`**: Defines the `PromptInput` widget for user input.
- **`src/genie_cli/widgets/chatbox.py`**: Defines the `Chatbox` widget for displaying messages.

## License

This project is licensed under the Valory License. See the [LICENSE](LICENSE) file for details.
Dennistest 0.0.1
A small example package
Requires Python: >=3.7

# Homework_4

URL for GitHub repository: https://github.com/2545046941/Homework_4

# graghs_Dennis

This package implements Dijkstra's algorithm.

# Installation 

You can install the package using : 

pip install git+https://github.com/2545046941/Homework_4.git

pip3 install git+https://github.com/2545046941/Homework_4.git

# Run Dijkstra's algorithm

python test.py - path-to-graph-file 

Example: python test.py example1.txt