semvec/pypi-packages huggingface dataset:
parsr-client 3.2.3
Python client for Parsr - Transforms PDF, Documents and Images into Enriched Structured Data
Requires Python: >=3.8,<4.0

# Parsr Client

Provides a python interface to the Parsr tool via its API.
Parsr transforms PDF, documents and images into enriched, structured data.

Find out all about Parsr (including download) at [https://github.com/axa-group/Parsr](https://github.com/axa-group/Parsr).

## 1 Installation

```sh
pip install parsr-client
```

## 2 Usage

_Make sure that the Parsr Server is already running. Let us suppose that the address is `localhost:3001`_

### 2.1 Connect to the Parsr server

```python
from parsr_client import ParsrClient
parsr = ParsrClient('localhost:3001')
```

### 2.2 Send the document

```python
parsr.send_document(
   file_path='README.pdf',
   config_path='defaultConfig.json'
   document_name='The Readme',
   save_request_id=True)
```

### 2.4 Retrieve results

1. Get everything as a JSON:

    ```python
    parsr.get_json()
    ```

2. As Markdown:

    ```python
    parsr.get_markdown()
    ```

3. As text:

    ```python
    parsr.get_text()
    ```

4. Get the first table on the first page:

    ```python
    parsr.get_table(
        page=1,
        table=1,
    )
    ```

5. Get all the versions of the document:

    ```python
    parsr.get_revisions('The Readme')
    ```

6. Get pretty diffs between each successive pair of a document's revisions:

    ```python
    parsr.compare_revisions('The Readme', pretty_html=True)
    ```

## 3 Interpreting the whole JSON output locally

The supplied `ParsrOutputInterpreter` class can be used to interpret the downloaded JSON output and generate higher level structures like the text body.

Here's an example to generate text body on the first page from the above example.

``` python
from parsr_client import ParsrOutputInterpreter

parsr_interpreter = ParsrOutputInterpreter(
    parsr.get_json()
)

t = parsr_interpreter.get_text(
    page_number=1
)
print(t)
```
crazy-piano 0.0.1
A package for exploring the fundamentals of how we define music.

crazy-piano
===========
Assists in the exploration of how we **define** music. Currently generates a set of frequencies for any number of notes in an octave. 10-keys-per-octave keyboard? Why not!

Installation (with pip)
-----------------------
`pip install crazy-piano`

Functionality
==============

List of Functions
-------------------------------------------------
 - **compute_frequencies(m=12, f0=440, base=2, low_thresh=20, high_thresh=8000)**: Generates a set of frequencies corresponding to different numbers of notes per octave. Based on a modified version of the [formula for computing frequencies in an octave.](https://pages.mtu.edu/~suits/NoteFreqCalcs.html) 
	 -  m: The number of steps in an octave. 12 is standard.
	 - f0: Baseline frequency. 440 Hz is conventional starting point for A4 pitch.
	 - base: The base of growth for frequencies. Determines how fast the frequencies increase.
	 - low_thresh: The lowest frequency allowed. 20 Hz is low limit of human hearing.
		 - When `low_thresh` is met, still finishes the octave. i.e. If the 3rd note of an octave is below `low_thresh`, will still return the 1st and 2nd notes of that octave.
	 - high_thresh: The highest frequency allowed. 8000 Hz traditionally the 8th octave.
		 - When `high_thresh` is met, still finishes the octave. i.e. If the `m-2` note of an octave is above `high_thresh` , will still return the `m-1` and `m` notes of that octave.

*Ideas for more? Create an issue, or email mikealtonji@gmail.com with feedback.*

Usage
-------------------------------------------------
Creates a pandas dataframe containing the frequencies for each note, where 440 Hz is the base value. Uses default values for low and high frequency cut-offs.
```
from crazy_piano import compute_frequencies
keyboard_10_notes = compute_frequencies(m=10)
```
Output Dataframe Columns
-------------------------------------------------

Octave: `f0` is the reference point. It is the 0th note of the 0th octave. `Octave`s lower are negative, and larger are positive. Integer.
Note Number: `f0` is the reference point. It is the 0th note of any octave. The largest `Note Number` is therefore `m-1`. Integer.
Frequency (Hz): The frequency corresponding to the `Octave` and `Note Number`, in Hertz. Float.

Contributors
============
* Michael Altonji
*Interested in collaborating? Email mikealtonji@gmail.com, or submit issues for features you'd like to see in the future!*

License
=======
[MIT License](https://opensource.org/licenses/MIT)
cargo-venv 0.0.6
Cargo Virtual Environment
Requires Python: >=3.7
Keywords: git user access management

# Cargo Virtual Environment

A virtual environment tool similar to Python's virtual environments.


## Table of Contents
* [Installation](#installation)
* [Usage](#usage)
    * [Custom toolchain](#custom-toolchain)
    * [IDE Support](#ide-support)
        * [IntelliJ Idea](#intellij-idea)

## Installation

```
pip install cargo-venv
```

## Usage
Leveraging `Cargo`'s built-in command mechanism, you can simply call the following command to get a virtual environment called
`venv`. 
```
cargo venv
```

However, since this is a Python script, you can specify a different name by calling:
```
cargo-venv custom-name
```

### Custom toolchain
You can also specify a custom toolchain rather than always depend on the latest. If a `rust-toolchain` file is discovered
in your project, that version will be used to install the toolchain inside your virtual environment.

### IDE Support
#### IntelliJ Idea
Under `Settings > Languages and Frameworks > Rust` set the following fields to these values:
#### Toolchain Location
```
<venv-path>/.rustup/toolchains/<toolchain-version>/bin
```
#### Standard library 
```
<venv-path>/.rustup/toolchains/<toolchain-version>/lib/rustlib/src/rust
```