semvec/pypi-packages huggingface dataset:
SpotiFLAC 0.2.0
Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
Requires Python: >=3.9

<h1>SpotiFLAC Python Module</h1>
<p>Integrate SpotiFLAC directly into your Python projects. Perfect for building custom telegram bots, automation tools, or web interfaces. <br> Also available as a <a href="https://github.com/jelte1/SpotiFLAC-Command-Line-Interface">CLI tool</a> and <a href="https://github.com/afkarxyz/SpotiFLAC">GUI tool</a>.</p>
<a href="https://pypi.org/project/SpotiFLAC">Module in Pypi</a>
<h2>Function Signature</h2>
<pre>
from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url: str,
    output_dir: str,
    services: list = ["tidal", "deezer", "qobuz", "amazon"],
    filename_format: str = "{title} - {artist}",
    use_track_numbers: bool = False,
    use_artist_subfolders: bool = False,
    use_album_subfolders: bool = False,
    loop: int = None
)
</pre>

<h2>Parameters</h2>
<i>url (str)</i><br>
The Spotify URL (Track, Album, or Playlist) you want to download.<br><br>

<i>output_dir (str)</i><br>
The directory path where the files will be saved.<br><br>

<i>services (list)</i><br>
A list of strings specifying which services to use and the priority order. <br>
Options: <code>"tidal"</code>, <code>"qobuz"</code>, <code>"deezer"</code>, <code>"amazon"</code>.<br>
Example: <code>["qobuz", "tidal"]</code>.<br><br>

<i>filename_format (str)</i><br>
Specify the format for naming downloaded files. Available placeholders:<br>
<code>{title}, {artist}, {album}, {track}, {date}, {year}, {position}, {isrc}, {duration}</code>.<br>
Default is <code>"{title} - {artist}"</code>.<br><br>

<i>use_artist_subfolders (bool)</i><br>
Set to <code>True</code> to organize downloaded files into subfolders by artist.<br><br>

<i>use_album_subfolders (bool)</i><br>
Set to <code>True</code> to organize downloaded files into subfolders by album.<br><br>

<i>loop (int)</i><br>
Specify the duration in minutes to keep retrying downloads in case of failures. Default is <code>None</code> (no retries).<br>

<h3>Example usage:</h3>
<pre>
from SpotiFLAC import SpotiFLAC

# Simple Download
SpotiFLAC(
    url="https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT",
    output_dir="./downloads"
)

# Advanced Configuration
SpotiFLAC(
    url="https://open.spotify.com/album/41MnTivkwTO3UUJ8DrqEJJ",
    output_dir="./MusicLibrary",
    services=["qobuz", "amazon", "tidal"],
    filename_format="{year} - {album}/{track}. {title}",
    use_artist_subfolders=True,
    use_album_subfolders=True
)
</pre>
schemax-cli 0.1.0
Infer JSON Schema from sample data — merge multiple examples, output Draft 2020-12 schemas.
Requires Python: >=3.8
Keywords: json, schema, infer, cli, jsonschema, developer-tools

# schemax

Infer JSON Schema from sample data. Feed it one or more JSON files and get a clean, mergeable schema back.

## Install

```bash
pip install schemax-cli
```

## Usage

```bash
# Infer schema from a single file
schemax infer data.json

# Infer from multiple examples (schemas are merged)
schemax infer example1.json example2.json example3.json

# Infer from a JSON array (each element = sample)
schemax infer users.json

# From stdin
cat data.json | schemax infer -

# With title and compact output
schemax infer data.json --title "User" --compact

# Disable format detection
schemax infer data.json --no-formats

# Different draft version
schemax infer data.json --draft 7
```

### Commands

| Command | Description |
|---------|-------------|
| `schemax infer` | Infer JSON Schema from sample data |
| `schemax diff` | Show property differences across array elements |
| `schemax validate` | Validate JSON and show structure summary |

### Format Detection

Automatically detects and annotates string formats:

- `date-time` — ISO 8601 timestamps
- `date` — YYYY-MM-DD dates
- `time` — HH:MM:SS times
- `email` — Email addresses
- `uri` — HTTP(S) URLs
- `uuid` — UUIDs
- `ipv4` — IPv4 addresses

### Multi-File Merging

When given multiple files (or a JSON array), schemax merges schemas intelligently:
- Object properties from all samples are combined
- `required` = intersection (only keys present in ALL samples)
- Types are widened (integer + number → number)
- Nullable fields are detected
- Conflicting types produce `anyOf`

## For AI Agents

See [SKILL.md](SKILL.md) for agent-optimized documentation.

## License

MIT
ezmsg-baseproc 1.5.1
Base processor classes and protocols for ezmsg signal processing pipelines
Requires Python: >=3.10

# ezmsg-baseproc

Base processor classes and protocols for building message-processing components in [ezmsg](https://github.com/ezmsg-org/ezmsg).

## Installation

```bash
pip install ezmsg-baseproc
```

Or install the latest development version:

```bash
pip install git+https://github.com/ezmsg-org/ezmsg-baseproc@dev
```

## Overview

``ezmsg-baseproc`` provides abstract base classes for creating message processors that can be used both standalone and within ezmsg pipelines. The package offers a consistent pattern for building:

* **Protocols** - Type definitions for processors, transformers, consumers, and producers
* **Processors** - Transform input messages to output messages
* **Producers** - Generate output messages without requiring input
* **Consumers** - Accept input messages without producing output
* **Transformers** - A specific type of processor with typed input/output
* **Stateful variants** - Processors that maintain state across invocations
* **Adaptive transformers** - Transformers that can be trained via ``partial_fit``
* **Composite processors** - Chain multiple processors together efficiently

All base classes support both synchronous and asynchronous operation, making them suitable for offline analysis and real-time streaming applications.

## Usage

### Creating a Simple Transformer

```python
from dataclasses import dataclass
from ezmsg.baseproc import BaseTransformer
from ezmsg.util.messages.axisarray import AxisArray, replace

@dataclass
class MySettings:
    scale: float = 1.0

class MyTransformer(BaseTransformer[MySettings, AxisArray, AxisArray]):
    def _process(self, message: AxisArray) -> AxisArray:
        return replace(message, data=message.data * self.settings.scale)
```

### Creating a Stateful Transformer

```python
from ezmsg.baseproc import BaseStatefulTransformer, processor_state

@processor_state
class MyState:
    count: int = 0
    hash: int = -1

class MyStatefulTransformer(BaseStatefulTransformer[MySettings, AxisArray, AxisArray, MyState]):
    def _reset_state(self, message: AxisArray) -> None:
        self._state.count = 0

    def _process(self, message: AxisArray) -> AxisArray:
        self._state.count += 1
        return message
```

### Creating an ezmsg Unit

```python
from ezmsg.baseproc import BaseTransformerUnit

class MyUnit(BaseTransformerUnit[MySettings, AxisArray, AxisArray, MyTransformer]):
    SETTINGS = MySettings
    # That's all - the base class handles everything else!
```

## Development

We use [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for development.

1. Install `uv` if not already installed
2. Clone and cd into the repository
3. Run `uv sync` to create a `.venv` and install dependencies
4. Run `uv run pytest tests` to run tests
5. (Optional) Install pre-commit hooks: `uv run pre-commit install`

## License

MIT License - see [LICENSE](LICENSE) for details.