semvec/pypi-packages huggingface dataset:
GLODAP 0.1
GLODAP downloader and importer in Python 
Requires Python: >=3.10

# glodap

Download [GLODAP](https://glodap.info) datasets and import them as pandas DataFrames.

## Install

    pip install glodap
    conda install conda-forge::glodap

## Use

The functions `arctic`, `atlantic`, `indian`, `pacific` and `world` import the latest version of the GLODAP dataset for the corresponding region, first downloading the file if it's not already saved locally.  For example:

```python
import glodap
df_atlantic = glodap.atlantic()
```

Files are saved by default at `"~/.glodap"`, but this can be controlled with the
kwarg `gpath`.  See the function docstrings for more information.

The columns of the imported DataFrames are renamed so that they can be passed
directly into [PyCO2SYS v2](https://github.com/mvdh7/PyCO2SYS):

```python
import PyCO2SYS as pyco2
co2s_atlantic = pyco2.sys(data=df_atlantic, nitrite=None)
```

Note `nitrite=None` - this means PyCO2SYS will ignore the `"nitrite"` column,
which is necessary because PyCO2SYS includes the nitrite-nitrous acid
equilibrium but its equilibrium constant is valid only under lab conditions.

The columns are the same as in the original GLODAP .mat files available from [glodap.info](https://glodap.info), except:
  * The `"G2"` at the start of each parameter has been removed.
  * Flags end with `"_f"` instead of just `"f"`.
  * There is a `"datetime"` column, which combines the `"year"`, `"month"` and `"day"` but NOT the `"hour"` and `"minute"` (because some of these are missing).
  * For compatibility with PyCO2SYS:
     - `"tco2"` => `"dic"`
     - `"talk"` => `"alkalinity"`
     - `"phts25p0"` => `"ph_lab"`
     - `"phtsinsitutp"` => `"ph_insitu"`
    
    Therefore when passing the DataFrame directly to PyCO2SYS as in the example
    above, the system will be solved from DIC and alkalinity, not pH.

The functions `download` and `read` can also be used for finer control, such as
specifying a particular GLODAP version rather than using the latest one.  See
their function docstrings for more information.
fastapi-key-auth 0.15.5
API key validation Middleware
Requires Python: <4.0,>=3.9
Keywords: api key, fastapi, security

<br />
<p align="center">
  <h3 align="center">FastAPI-key-auth</h3>

  <p align="center">
    Secure your FastAPI endpoints using API keys.
    <br />
    <a href="https://github.com/iwpnd/fastapi-key-auth/issues">Report Bug</a>
    ·
    <a href="https://github.com/iwpnd/fastapi-key-auth/issues">Request Feature</a>
  </p>
</p>

<!-- TABLE OF CONTENTS -->
<details open="open">
  <summary><h2 style="display: inline-block">Table of Contents</h2></summary>
  <ol>
    <li>
      <a href="#about-the-project">About The Project</a>
      <ul>
        <li><a href="#built-with">Built With</a></li>
      </ul>
    </li>
    <li>
      <a href="#getting-started">Getting Started</a>
      <ul>
        <li><a href="#installation">Installation</a></li>
      </ul>
    </li>
    <li><a href="#usage">Usage</a></li>
    <li><a href="#license">License</a></li>
    <li><a href="#contact">Contact</a></li>
  </ol>
</details>

<!-- ABOUT THE PROJECT -->

## About The Project

On deployment inject API keys authorized to use your service. Every call to a private
endpoint of your service has to include a `header['x-api-key']` attribute that is
validated against the API keys in your environment.
If it is present, a request is authorized. If it is not FastAPI return `401 Unauthorized`.
Use this either as a middleware, or as Dependency.

### Built With

-   [starlette](https://github.com/encode/starlette)
-   [fastapi](https://github.com/tiangolo/fastapi)

<!-- GETTING STARTED -->

## Getting Started

### Installation

1. Clone and install
    ```sh
    git clone https://github.com/iwpnd/fastapi-key-auth.git
    uv sync
    ```
2. Install with pip
    ```sh
    pip install fastapi-key-auth
    ```
3. Install with uv
    ```sh
    uv add fastapi-key-auth
    ```

## Usage

As Middleware:

```python
from fastapi import FastAPI
from fastapi_key_auth import AuthorizerMiddleware

app = FastAPI()

app.add_middleware(AuthorizerMiddleware, public_paths=["/ping"], key_pattern="API_KEY_")

# optional use regex startswith
app.add_middleware(AuthorizerMiddleware, public_paths=["/ping", "^/users"])
```

As Dependency

```python
from fastapi import FastAPI, Depends
from fastapi_key_auth import AuthorizerDependency

authorizer = AuthorizerDependency(key_pattern="API_KEY_")

# either globally or in a router
app = FastAPI(dependencies=[Depends(authorizer)])
```

## License

Distributed under the MIT License. See `LICENSE` for more information.

<!-- CONTACT -->

## Contact

Benjamin Ramser - [@imwithpanda](https://twitter.com/imwithpanda) - ahoi@iwpnd.pw
Project Link: [https://github.com/iwpnd/fastapi-key-auth](https://github.com/iwpnd/fastapi-key-auth)
keytake-datareader 0.1.8
A package for extracting and formatting content from various sources
Requires Python: >=3.7

# DataReader

A Python package for extracting and formatting content from various sources including PDFs, URLs, videos, and audio files.

## Features

- PDF processing with multiple backends (PyMuPDF, pypdf, markitdown)
- Web page content extraction
- Video content processing
- Audio transcription
- Markdown formatting

## Installation

```bash
pip install keytake-datareader
```

All dependencies are included with the package by default, so you can immediately use all features without installing additional packages.

## Quick Start

```python
from datareader import DataReader

# Process a PDF file
text = DataReader.read_pdf("document.pdf")

# Process a URL
web_content = DataReader.read_url("https://example.com")

# Process a video file
transcript = DataReader.read_video("video.mp4")

# Process an audio file
audio_text = DataReader.read_audio("audio.mp3")

# Save as markdown
DataReader.save_markdown(text, "output.md")
```

## Command Line Usage

The package provides command-line scripts for batch processing:

```bash
# Process PDFs
./run_pdf.sh

# Process URLs
./run_url.sh
```

## Contributing

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

## License

This project is licensed under the MIT License - see the LICENSE file for details.
minBlepy 19
MinBLEPs library including fast naive waveform conversion

# minBlepy
MinBLEPs library including fast naive waveform conversion.

## Install
These are generic installation instructions.

### To use, disposably
Install the current release from PyPI to a virtual environment:
```
python3 -m venv venvname
venvname/bin/pip install -U pip
venvname/bin/pip install minBlepy
. venvname/bin/activate
```

### To use, permanently
```
pip3 install --break-system-packages --user minBlepy
```
See `~/.local/bin` for executables.

### To develop
First install venvpool to get the `motivate` command:
```
pip3 install --break-system-packages --user venvpool
```
Get codebase and install executables:
```
git clone git@github.com:combatopera/minBlepy.git
motivate minBlepy
```
Requirements will be satisfied just in time, using sibling projects with matching .egg-info if any.

## API

<a id="minBlepy"></a>

### minBlepy

<a id="minBlepy.floatdtype"></a>

###### floatdtype

Common data type of naive values and digital audio sample points, effectively about 24 bits.

<a id="minBlepy.minblep"></a>

### minBlepy.minblep

<a id="minBlepy.minblep.MinBleps"></a>

#### MinBleps Objects

```python
class MinBleps()
```

<a id="minBlepy.minblep.MinBleps.paste"></a>

###### paste

```python
def paste(naivex, diffbuf, outbuf)
```

Add minBLEPs to `outbuf` for the differentiated naive signal block in `diffbuf`.
The first element of `diffbuf` should be the first naive value in the current block minus the last naive value of the previous block.
The `naivex` is the index of the first naive value, modulo `naiverate`.
The `outbuf` must have enough space for overflow of the last possible minBLEP, and should be initialised to the overflow section of the previous `outbuf` and otherwise zero.
recursivX 1.0.1
Recursive archive extractor with password detection
Requires Python: >=3.6

# 🔐 Recursive Archive Extractor

```
 ▄▄▄ ▗▞▀▚▖▗▞▀▘█  ▐▌ ▄▄▄ ▄▄▄ ▄ ▄   ▄ ▗▖  ▗▖
█    ▐▛▀▀▘▝▚▄▖▀▄▄▞▘█   ▀▄▄  ▄ █   █  ▝▚▞▘ 
█    ▝▚▄▄▖         █   ▄▄▄▀ █  ▀▄▀    ▐▌  
                            █       ▗▞▘▝▚▖
```

> A powerful Python tool that **recursively extracts nested archive files**, logs password-protected ZIPs, and handles multiple compression formats with style.

---

## 📦 Supported Formats

- `.zip` (with password detection)
- `.xz`
- `.bz2`
- `.gz`
- `.tar`

---

## 🚀 Features

- 📂 Recursively unpacks deeply nested archive layers.
- 🧠 Auto-detects archive types based on file headers.
- 🛡️ Detects and logs password-protected ZIPs.
- 🪵 Writes extraction logs per layer.
- 📁 Copies final locked ZIP layer for further analysis.
- 🖼️ Clean structure and modular design.

---

## 🛠️ Installation

```bash
git clone https://github.com/Paul00/recursivX.git
cd recursivX
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt  # Currently, no third-party modules required
```

---

## 🧪 Usage

```bash
python recursivX.py input_archive.ext -o output_folder
```

### Example:

```bash
python recursivX.py sample.zip -o unpacked_layers
```

---

## 📁 Output Structure

```
extracted/
├── layer_1/
│   └── ...
├── layer_2/
│   └── ...
├── final_locked_layer.zip  ← If password-protected
└── extraction_log.txt      ← Full extraction log
```

---

## 📓 Log Format

Each extraction layer is logged with detected archive type and filename. If password protection is found, you'll see:

```
[Layer 3] sample_protected.zip requires password
  → Encapsulated files: secret.txt, data.json
```

---

## 🙏 Credits

Crafted with care by [Paul00](https://github.com/Paul00)

---

## 📜 License

MIT License – do whatever you want, just don’t claim you wrote it 😉
listrindex 0.1
Helps to find the last index of the element in list

# listrindex

A lightweight Python utility that allows you to find the **last index** of an element in a list â€” something the built-in `list.index()` method does not support.

---

## ðŸ“Œ Description

In Python, `list.index(x)` returns the **first index** of `x` in a list.  
The `listrindex` class provides the method `rindex(list, object)` that returns the **last index** where the object appears.

This is especially useful when working with large datasets or when you want to find the last occurrence of repeated elements.

---

## âœ… Features

- Returns the **last index** of a given value in a list.
- Works with integers, strings, or any data type.
- Raises `ValueError` if the element is not found, just like `list.index()`.

---

## ðŸ§ª Usage

```python
from listrindex import listrindex

mylist = [5, 3, 7, 3, 9, 3]
value = 3

r = listrindex()
print(r.rindex(mylist, value))  # Output: 5 (last index of 3)
streamlit-math-keyboard 0.1.1
A custom Streamlit component for a math input keyboard.
Requires Python: >=3.7


**Key things to customize/add:**

1.  **`[![PyPI version](...)](...)`**: Once your package is on PyPI, update this badge. You can get the markdown from [shields.io](https://shields.io/) or directly from your PyPI project page.
2.  **`placeholder_screenshot.png`**: **Definitely replace this!** Take a nice screenshot of your component in action within a Streamlit app and add it to your repository (e.g., in the root or an `assets/` folder) and update the link.
3.  **`yourusername` / `your.email@example.com`**: Update these in the `setup.py` section and potentially in the README if you list yourself as the author.
4.  **GitHub URL**: Update the `url` in `setup.py` and any links in the README to point to your actual GitHub repository.
5.  **`LICENSE.txt`**: Create this file in your project root and paste the text of your chosen license (e.g., MIT License).
6.  **More Examples:** If your component has more advanced features or common use cases, add more examples to the "Usage" section.
7.  **`requirements.txt` (for development):** If your development environment needs more than just `streamlit`, create a `requirements.txt` in the root and list them.

This README provides a solid foundation for users to understand, install, and use your component. Good luck with the publishing!