semvec/pypi-packages huggingface dataset:
turnout-tier-categorization 0.2.0
A function to add a turnout tier categorization column to a pandas DataFrame
Requires Python: >=3.6

# Turnout Tier Categorization

This Python script contains a function `add_turnout_tier` that adds a new categorical column called `turnout_tier` to a pandas DataFrame. The categorization is based on the values in a specified numeric column.

## Function Description

### `add_turnout_tier`

Adds a new categorical column `turnout_tier` to the DataFrame based on the specified numeric column.

#### Parameters:

- `df` (pandas.DataFrame): The DataFrame containing the numeric column.
- `numeric_column` (str): The name of the numeric column to base the `turnout_tier` on.

#### Returns:

- pandas.DataFrame: The DataFrame with the new `turnout_tier` column added.

### Turnout Tier Criteria:

- **> 80**: "Very likely to vote regardless of campaign"
- **70-79**: "Turnout Tier 1"
- **50-69**: "Turnout Tier 2"
- **30-59**: "Turnout Tier 3"
- **< 30**: "Very unlikely to vote regardless of campaign"

## Usage

### Example

```python
import pandas as pd

# Define the function
def add_turnout_tier(df, numeric_column):
    def categorize_turnout(value):
        if value > 80:
            return "Very likely to vote regardless of campaign"
        elif 70 <= value <= 79:
            return "Turnout Tier 1"
        elif 50 <= value <= 69:
            return "Turnout Tier 2"
        elif 30 <= value <= 59:
            return "Turnout Tier 3"
        else:
            return "Very unlikely to vote regardless of campaign"

    df['turnout_tier'] = df[numeric_column].apply(categorize_turnout)
    return df

# Example usage
data = {
    'voter_score': [85, 75, 60, 45, 25]
}
df = pd.DataFrame(data)
df = add_turnout_tier(df, 'voter_score')
print(df)
pdfsim 0.3
A CLI tool to find similar PDF in a given directory
Requires Python: >=3.6

# PDF Similarity Matcher

The **PDF Similarity Matcher** is a command-line tool for finding and displaying PDF documents similar to a given input PDF based on extracted text features. It leverages text extraction and similarity comparison to help you identify relevant matches from a directory of PDFs.

## Features

- Extracts text from PDF files.
- Processes and compares features from multiple PDFs.
- Calculates similarity scores between an input PDF and PDFs in the directory.
- Optionally displays detailed key-value feature information for similar PDFs.

## Installation

Follow these steps to install and set up the PDF Similarity Matcher:

1. **Clone the repository:**

    ```bash
    git clone https://github.com/yourusername/pdfsim.git
    cd pdfsim
    ```

2. **Create a virtual environment:**

    ```bash
    python3 -m venv venv
    ```

3. **Activate the virtual environment:**

    - **On Windows:**

      ```bash
      venv\Scripts\activate
      ```

    - **On macOS/Linux:**

      ```bash
      source venv/bin/activate
      ```

4. **Install the required packages:**

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

    Ensure `requirements.txt` includes the necessary libraries:

    ```
    PyPDF2
    scikit-learn
    nltk
    ```

## Usage

To find similar PDFs, use the following command:

```bash
python3 main.py -d <directory_containing_pdf> -i <input_pdf> -t <top_n> [-kv]
```

## Arguments
- -d, --database (required): Path to the directory containing PDF files to compare against.
- -i, --input (required): Path to the input PDF file you want to compare.
- -t, --top (optional, default: 1): Number of top similar PDFs to display.
- -kv (optional): Enable detailed key-value feature output for similar PDFs.
metadata-validator 0.1.6
A package designed to put a spreadsheet of a brain imagery dataset into a series of required metadata validation for within data in cells.
Keywords: python, bil, metadata, validator, metadata validator

### Metadata Validation Package
>
>****
>
>> #### About
>>
>> The metadata validation package is meant for the use of the Brain Image Library. The metadata dependencies match the required checkpoints for the submission of an Excel spreadsheet. The spreadsheet needs to match required criteria for a brain imagery dataset with supporting information.
>>
>> #### Instructions on Installation
>>
>> The steps to correctly install the package to a Linux system are:
>>
>> 1. Setup Virtual environment for package dependencies on command line Linux Interface within desired directory
>>
>>      * **$ python3 -m venv venv_for_package**
>>
>> 2. Activate Virtual Environment
>>
>>      * **$ source venv_for_package/bin/activate**
>> 3. Move into desired directory for package to pip install Metadata Validation Package
>>
>>      * **$ pip install metadata_validator**
>
> ****
>
>> #### Using Metadata Validation Package
>>
>> To start using the Metadata Validation package, the directory that the package was installed to has to be current directory path. The spreadsheet that is being checked will be located in this same directory as well for easy use of the package. The spreadsheet can also be placed in a different directory within the Linux system, but the first option is recommended.
>>
>> 1. Get to Python3 Shell Command Line
>>
>>      * **$ python3**
>>
>> 2. Import package from Linux directory to Python3 shell
>>
>>      * **>>> import metadata_validator**
>>
>> 3. Run function from package for metadata validation
>>
>>      * **>>> metadata_validator.outside_bil_check()**
>>
>>After running this command, the package will begin to operate and ask the user for an input of an absolute pathway to a excel spreadsheet
>>
>> 4. Give desired spreadsheet path
>>
>>      * Method 1: **>>> current_directory/spreadsheet.xlsx**
>>
>>      * Method 2: **>>> ~/path_to_spreadsheet/spreadsheet.xlsx**
>>
>> This will prompt a choice of a Ingest Method for different checks of different sheets within file.
>>
>> 5. Give Ingest Method
>>
>>      * **Choice of a number one through five**
>>
>>Once completed, the package will sift through different sheets within the spreadsheet checking metadata for valid inputs of information.
visionlit 1.0.11
A Python library implementing Visionlit computer vision methods with model access.
Requires Python: >=3.6


# Visionlit Package

## Overview


Visionlit is a Python package designed for advanced computer vision tasks. It provides a robust command-line interface and can be seamlessly integrated into Python scripts for a variety of operations including image segmentation, colorization, face ID verification, and smart object detection.

For more information and live examples, please visit our web platform at [myvisionlit.com](http://myvisionlit.com). 

To interact with the methods provided by Visionlit, you will need to create an account on this platform to obtain an API key.

## Features

- **Image Segmentation**: Implement custom segmentation masks.
- **Black and White Conversion**: Convert color images or videos into grayscale.
- **Colorization**: Reintroduce color into grayscale images using machine learning.
- **Smart Object Detection**: Detect and identify objects within images, with options for custom display styles and color filters.
- **Face ID Verification**: Compare faces between two images to verify identity, useful in security and authentication.
- **Identity Data Extraction**: Extract and classify identity data from ID cards for specific supported countries.

## Installation

To install Visionlit, run the following command:

```bash
pip install visionlit
```

## Usage

### Command Line Interface

#### List Available Methods

To display all executable methods:

```bash
visionlit --list
```

#### Execute Specific Method

To run a specific method on an image:

```bash
visionlit <api_key> <image_path> <method_name> [--display] [--confidence] [--option] [--color] [--country] [--to_compare]
```

Parameters:
- `api_key`: Your API key for authentication.
- `image_path`: Path to the image file.
- `method_name`: The name of the method to execute.
- `display`: Type of display for detection results (e.g., Boxes, Masks).
- `confidence`: Confidence level for detection accuracy.
- `option`: Specific processing options.
- `color`: Color filter for object detection in "Masks" display type.
- `country`: Country code for ID card processing.
- `to_compare`: Path to an additional image file for face comparison.

### As a Python Module

Example of using Visionlit in a Python script:


```python
import os
import sys
from visionlit import Visionlit


print(dir(Visionlit))
if __name__ == "__main__":
    key = "56daa10w355169f608ced4b179286efdddd6860634h239jf61f6a38f20b98"
    vision = Visionlit(key)
    try:
        result = vision.segment_image("path to image or directory")
        print(result)
    except ValueError as e:
        print(e)
```
rstms-vimfix 0.1.17
Top-level package for rstms-vimfix.
Keywords: rstms, vim, quickfix, rstms-vimfix

rstms-vimfix
============


![Image](https://img.shields.io/github/license/rstms/rstms-vimfix)

![Image](https://img.shields.io/pypi/v/rstms-vimfix.svg)




Run a compile command and process the output for vim quickfix mode


* Free software: MIT license
* Documentation: https://rstms-vimfix.readthedocs.io.



Credits
-------

This package was created with Cookiecutter and `rstms/cookiecutter-python-cli`, a fork of the `audreyr/cookiecutter-pypackage` project template.

[audreyr/cookiecutter](https://github.com/audreyr/cookiecutter)
[audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage)
[rstms/cookiecutter-python-cli](https://github.com/rstms/cookiecutter-python-cli)
omie-client 0.3.0
Omie Client Python SDK
Requires Python: <4.0,>=3.9

## Omie's Python SDK

![Omie's Logo](https://raw.githubusercontent.com/morais90/omie-client/main/assets/omie-logo.jpeg)
<p align="center">An unofficial implementation of Omie's API. </p>

![PyPI - Version](https://img.shields.io/pypi/v/omie-client?style=flat)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/omie-client?style=flat)
[![codecov](https://codecov.io/github/morais90/omie-client/graph/badge.svg?token=09Q1ENULCS)](https://codecov.io/github/morais90/omie-client)


For a full reference of the API documentation look at Omie [Developer Portal](https://developer.omie.com.br/).

### Installation:
```shell
$ pip install omie-client
```

### Getting started
```python
>>> from omie_client import OmieClient
>>> omie_client = OmieClient(app_key="your-app-key", app_secret="your-app-secret")
>>> payment = omie_client.accounts_payable.get_by_id(9873625)
Payment(
    codigo_lancamento_omie=9873625,
    codigo_lancamento_integracao='MAJAWg',
    codigo_cliente_fornecedor=9809218639,
    data_vencimento=datetime.date(2024, 5, 14),
    ....
)
```

### Features

Our foundation is built upon established and modern libraries.

- [HTTPX - A next-generation HTTP client for Python.](https://github.com/encode/httpx)
- [Pydantic - Data validation using Python type hints.](https://github.com/pydantic/pydantic)

### Contributing

Would you like to support this project and help it progress 🙏✨? Follow our [Contributing Guidelines](CONTRIBUTING.md)