semvec/pypi-packages huggingface dataset:
pdf-orientation-corrector 0.1.4
A Python module to automatically detect and correct the orientation of pages in PDF documents.
Requires Python: >=3.8,<4.0

# PDF Orientation Corrector

## Overview

The PDF Orientation Corrector is a Python module designed for automatic detection and correction of the orientation of pages in PDF documents.

## Key Features

- **Automated Page Orientation Correction**: Detects and corrects the orientation of text on each page of a PDF.
- **Batch Processing**: Enhances performance when dealing with large documents by processing pages in batches.
- **Image Preprocessing**: Uses PIL to enhance the accuracy of OCR results.

## Prerequisites

Before you begin, ensure you have met the following requirements:

Python 3.x
Libraries: PyPDF2, pytesseract, pdf2image, PIL (Pillow), concurrent.futures (part of the standard library)

## Installation

Clone the repository or download the source code. Install the required dependencies via pip:

```bash
pip install PyPDF2 pytesseract pdf2image Pillow
```

## Usage

The module can be used in two ways:

### As a Script

Run the script from the command line, providing the necessary arguments:

```bash
python pdf_orientation_corrector.py input.pdf output.pdf --batch_size 20 --dpi 300 --verbose
```

### As a Library

Import the module in your Python script:

```python
import pdf_orientation_corrector
# Use the module functions as needed
```

## Author

James Standbridge
Email: james.standbridge.git@gmail.com
fastroc-bright-lego 1.0.6
Quickly computes the ROC AUC score of a model
Requires Python: >=3.8
Keywords: roc,ROC,reciever operating characteristic

# fastroc
fastroc is a module that is able to approximate the ROC AUC score over an axis of two numpy arrays much faster than current 
alternatives. It does this at the expense of portability as it uses C to calculate the ROC AUC.

## Usage

To calculate the ROC AUC score, 2 arrays are needed:
* `y_true` - Whether that event actually happened
* `y_score` - The model's score of that event happening. The lower, the more likely. `y_score` should be in the range 0 
   to 1.

The function also takes in 3 optional arguments:
* `axis` (default `-1`) - Which axis to compute the score over
* `integral_precision` (default `50`) - The number of samples to use for the integration
* `thread_count` (default `1`) - The number of threads to use. A value of 1 keeps the program single threaded.

The array returned contains the roc scores.

## Building

First run:
```bash
git clone https://github.com/brightlego/fastroc.git
cd fastroc
```
Then run:
### Linux:
To build and install with you default Python3 installation, run 
```bash
bash build.sh
```

### Other
To build and install with another Python3 installation or on MacOS/Windows, run
```bash
<python-installation> -m build
<python-installation> -m pip install "$(ls dist/*.whl | sort -V | tail -n 1)" --force-reinstall
```

#### Notes for Windows:
This code is not tested on Windows and is unlikely to be able to use multithreading.
notrandom 1.0.0
Pseudorandom, 100% reproducible variable generators
Requires Python: >=3.7
Keywords: random,pseudorandom,generators

notrandom: Pseudorandom, 100% reproducible variable generators.

Implementation of the builtin 'random' API, which guarantees 100% deterministic and reproducible computation of values, regardless of python versions, operating system or environment (a guarantee that the 'random' module does not provide). Non randomness guaranteed!

For example, when seeding the generator with the integer 0, the those are the first 3 floating numbers, across all systems, Python Implementations and versions. Try it yourself! ::

    >> from notrandom import random, seed
    >> seed(0)
    >> print(random(), random(), random())
    0.40003172633476936 0.16874476805609495 0.07212944838504431

This package is based on the builtin 'random' module and strongly resembles its API, with only minor adjustments. In particular, all global functions of random are also available in notrandom, in addition to the notrandom.Random object which implements the random.Random api. Check out the test.py file for usage examples.

It is important to note that the values computed by the notrandom are actually not random at all, as the process is 100% deterministic (that is the whole point!). Obviously, it is not intended to be used cryptographically in any way or circumstance.

Behind the scenes, notrandom uses the cryptographic hash function SHA256, in a process that resembles the OFB mode of operation. The algorithm produces blocks of 256bits ad-hoc, by hashing the previous 256bit block using SHA256, where the initial block is derived from the key directly. Then using similar technics to the ones that 'random' uses, random floating point numbers and integers in range are derived when requested.
progressiveai 0.0.10
"This repository contains the Python library for ProgressiveAI, a powerful tool for interacting with AI Models. The library provides a simple and intuitive interface for sending requests to ProgressiveAI's AI Models and processing their responses."
Requires Python: >=3.9

# ProgressiveAI Python Library

Welcome to the official ProgressiveAI Python Library! This library allows you to easily connect with ProgressiveAI's powerful AI Models and integrate them into your Python projects.

## Installation

You can install the library using pip:

```bash
pip install progressiveai
```

## Getting Started

```python
# Call the official ProgressiveAI Python Library
# From the "progressiveai" library, import the "Chat" class to create a connection with ProgressiveAI's AI Models
from progressiveai import Chat

# Create a chat
chat = Chat(
    # Input your ProgressiveAI API Key
    api_key="keyid-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    text="Hello, AI!",  # Enter a question of your choice
    model="wispar"  # Mention the AI Model you want to use. Currently, we offer "WISPAR Lite", and soon "WISPAR" will also be available.
)

# Get AI response
# Fetch a response from the AI Model; if not included, the request will not be submitted and processed
response = chat.get_response()
print(response)  # Print the AI's response
```

Make sure to replace `"keyid-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` with your actual ProgressiveAI API key.

## Help and Support

If you need help or have any questions, feel free to reach out to us:

- **[ProgressiveAI Support](https://support.progressiveai.org/)**: Visit our support platform for assistance.
- **[ProgressiveAI Documentation](https://docs.progressiveai.org/)**: Check out our documentation for detailed information and guides.
- **[GitHub Repository](https://github.com/ProgressiveAI/progressiveai-python)**: Report issues or contribute to the development on GitHub.

We're here to help you make the most of ProgressiveAI's AI capabilities!
tratools 0.0.4.dev0
some helpful tools

# tra-tools
Some useful tools.

### Requirements
```
pip install -r requirements.txt
```

### Installation and running
```
pip install tratools
```

### Usage:

1. Progress:
```
>>> import tratools.progresses.progress_cmd as progress_cmd
>>> ProgressCmd = progress_cmd.ProgressCmd
>>> progress = ProgressCmd(steps, prefix="loading:")
>>> progress.succ(idx)  # somewhere in loop
>>> progress.print_end()
```

2. Zipper:
```
>>> from tratools.zipper import Zipper, Entry
>>> zipper = Zipper(
        init_entry=Entry(
            attrs_names=["A", "B"],
            attrs_values=[["a1", "a2", "a3"], ["b1", "b2", "b3"]],
            attrs_targets=["dtime", "goal"],
            max_step=10
        ), pack_size=2)

>>> zipper.load(use_backup=False)
>>> print("todos:")
>>> print(zipper.todos)
            A   B
        0  a1  b1
        1  a1  b2
        2  a1  b3
        3  a2  b1
        4  a2  b2
        5  a2  b3
        6  a3  b1
        7  a3  b2
        8  a3  b3

>>> pack, pack_size = zipper.next()
>>> pack = list(pack)
>>> print("pack:")
>>> for e in pack:
>>>     print(e.attrs_values_entry)

        A    a1
        B    b1
        Name: 0, dtype: object
        A    a1
        B    b2
        Name: 1, dtype: object

>>> print("\ntodos after pack:")
>>> print(zipper.todos)
            A   B
        2  a1  b3
        3  a2  b1
        4  a2  b2
        5  a2  b3
        6  a3  b1
        7  a3  b2
        8  a3  b3

>>> zipper.update(pack)
>>> print("\ntodos after update:")
>>> print(zipper.todos)
            A   B
        2  a1  b3
        3  a2  b1
        4  a2  b2
        5  a2  b3
        6  a3  b1
        7  a3  b2
        8  a3  b3

>>> print("\ndones after update")
>>> print(zipper.dones)
            A   B
        0  a1  b1
        1  a1  b2

```

3. CpuScheduler:
```
    >>> from tratools.scheduler import CpuScheduler
    >>> from tratools.zipper import Entry

    >>> scheduler = CpuScheduler(
    >>>    init_entry=Entry(
    >>>        attrs_names=["A", "B"],
    >>>        attrs_values=[["a1", "a2", "a3"], ["b1", "b2", "b3"]],
    >>>        attrs_targets=["dtime", "goal"],
    >>>        max_step=10
    >>>    ), 
    >>>    target_tasks_params_names=["length", "delay_cost"],
    >>>    dbg=True)
    
    >>> pack = scheduler.ientry.gen(4)
    >>> scheduler(pack)

    solution:
    (1_len_27_delay_4_0, cpu4, 0, 27)
    (2_len_19_delay_7_0, cpu1, 0, 19)
    (3_len_19_delay_7_0, cpu0, 0, 19)
    (0_len_33_delay_0_0, cpu5, 11, 44)

    # see `tratools.scheduler.test()` for details.
```
adj-dataparrots-5 0.0.1
A small example package
Requires Python: >=3.6


Copyright (c) 2021 The Python Packaging Authority
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
adj-dataparrots-4 0.0.7
A small example package
Requires Python: >=3.6


Copyright (c) 2021 The Python Packaging Authority
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.