semvec/pypi-packages huggingface dataset:
git-check-ignore 1.0.1
A Python wrapper around `git` to check filenames against `.gitignore` files
Requires Python: >=3.11
Keywords: git, gitignore

# git-check-ignore

This is a wrapper around git's [`check-ignore`](https://git-scm.com/docs/git-check-ignore)
command.

It can be used to determine if a particular pathname would be ignored by a repository's
`.gitignore` files. It shells out to `git` to accomplish this. This has the
disadvantage that you must have `git` installed and available on your PATH, but has the
advantage that this module's results will always agree with `git`'s.

[![Test, build, and publish](https://github.com/dd-dockyard/git-check-ignore/actions/workflows/publish.yml/badge.svg?branch=main)](https://github.com/dd-dockyard/git-check-ignore/actions/workflows/publish.yml)

## Installation

`git-check-ignore` can be [installed from PyPI](https://pypi.org/project/git-check-ignore/):

```sh
pip install git-check-ignore
```

## Documentation

Documentation can be found at <https://dd-dockyard.github.io/git-check-ignore/>

The source code can be found at <https://github.com/dd-dockyard/git-check-ignore>

## Example Usage

The `ignored_pathnames` and `not_ignored_pathnames` functions are the simplest way to use this module.
Given a list of names, they iterate through the names that would or would not be ignored by `git`:

```python
from git_check_ignore import ignored_pathnames, not_ignored_pathnames

for ignored in ignored_pathnames("README.md", "foo.py", "bar.py"):
    print(f"{ignored} is ignored")

for not_ignored in not_ignored_pathnames("README.md", "foo.py", "bar.py"):
    print(f"{not_ignored} is not ignored")
```

The `ignored_paths` and `not_ignored_paths` functions are the same, but return [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html) objects:

```python
from git_check_ignore import ignored_pathnames, not_ignored_pathnames

for ignored in ignored_paths("README.md", "foo.py", "bar.py"):
    if ignored.exists():
        print(f"{ignored} is ignored and exists")

for not_ignored in not_ignored_paths("README.md", "foo.py", "bar.py"):
    if not_ignored.exists():
        print(f"{not_ignored} is not ignored and exists")
```

The `git_check_ignore` function provides the most information, and allows you to determine which `.gitignore` pattern matched a particular pathname:

```python
from git_check_ignore import git_check_ignore

for r in git_check_ignore("README.md", "foo.py", "bar.py"):
    if r.ignored:
        print(f"{r.pathname} is ignored")
    if r.match:
        print(f"matched {r.match.pattern} at line {r.match.linenum} of {r.match.source}")
```

## License

This software is provided under the terms of the [AGPL 3.0](https://www.gnu.org/licenses/agpl-3.0.txt) license.
mcp-applemusic 0.1.5
A simple Apple Music API client for MCP
Requires Python: >=3.13

# MCP-AppleMusic

A FastMCP server implementation for controlling Apple Music (formerly iTunes) on macOS through AppleScript commands.

## Requirements

- Python 3.13+
- macOS with Apple Music app installed
- MCP library ≥1.2.1

## Installation

First, ensure you have uv installed:
```bash
$ brew install uv
```

Then, with **Claude Desktop**, add the following to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "iTunesControlServer": {
      "command": "uvx",
      "args": ["-n", "mcp-applemusic"]
    }
  }
}
```

## Available Commands

The following commands are available through the MCP server:

```python
itunes_play()         # Start playback
itunes_pause()        # Pause playback
itunes_next()         # Skip to next track
itunes_previous()     # Go to previous track
itunes_search(query)  # Search library for tracks
itunes_play_song(song)  # Play specific song
itunes_create_playlist(name, songs)  # Create new playlist
itunes_library()      # Get library statistics
```

## Usage

Start the server:

```bash
python server.py
```

Example interactions:

```python
# Search for a song
results = itunes_search("Hey Jude")

# Create a new playlist
itunes_create_playlist("Beatles Favorites", ["Yesterday", "Hey Jude", "Let It Be"])

# Play a specific song
itunes_play_song("Hey Jude")
```

## Development

1. Clone the repository:
```bash
git clone https://github.com/yourusername/mcp-applemusic.git
cd mcp-applemusic
```

2. Install development dependencies:
```bash
pip install -e ".[dev]"
```

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Notes

- This tool only works on macOS systems due to its AppleScript dependency
- Requires Apple Music (formerly iTunes) to be installed
para-cli 0.1.1
A command line tool for managing your PARA system
Requires Python: >=3.13
Keywords: para, productivity, organization, cli

# PARA CLI

A command-line tool for managing your personal knowledge using the PARA method (Projects, Areas, Resources, Archive).

> ⚠️ **Development Status**: This project is currently under active development. Features and interfaces may change significantly between versions. Please check the releases page for stable versions and breaking changes.

![CLI Interface](cli-interface.png)

## Installation

Install para-cli using uv (recommended for reliable installation and dependency management):

```bash
uv tool install para-cli
```

This will install para-cli globally in an isolated environment, ensuring all dependencies are properly managed.

⚠️ Note: Direct installation via pip is not recommended as it may cause system dependency conflicts.

Requirements:
- Python 3.13 or later
- uv package manager (install from https://github.com/astral-sh/uv)

## Usage

### Interactive Mode

The easiest way to manage your PARA system is through the interactive mode:

![Interactive Interface](interactive.svg)

### Initialize PARA Structure

Create the basic PARA directory structure:

```bash
para init
```

You can also specify a custom location:

```bash
para init --path ~/Documents/PARA
```

### Check Status

View the current status of your PARA system:

```bash
para status
```

### Add New Items

Add a new item to any PARA category:

```bash
para add "New Project" projects
para add "Health" areas
para add "Programming Books" resources
para add "Old Project 2023" archive
```

## PARA Method Overview

The PARA method is a simple but powerful organizational system:

- **Projects**: Short-term efforts that you're currently working on
- **Areas**: Long-term responsibilities you want to manage
- **Resources**: Topics or themes of ongoing interest
- **Archive**: Inactive items from the other categories

## Development

Requirements:
- Python 3.13+
- Dependencies: typer, rich, textual

To contribute:
1. Clone the repository
2. Install dependencies: `uv pip install -e .`
3. Make your changes
4. Submit a pull request

## License

MIT License
batch-prediction-pipeline_amar 0.1.0
A batch prediction pipeline for energy consumption forecasting
Requires Python: <3.10,>=3.9

# Batch Prediction Pipeline

Check out [Lesson 3](https://towardsdatascience.com/unlock-the-secret-to-efficient-batch-prediction-pipelines-using-python-a-feature-store-and-gcs-17a1462ca489) on Medium to better understand how we built the batch prediction pipeline. 

Also, check out [Lesson 5](https://towardsdatascience.com/ensuring-trustworthy-ml-systems-with-data-validation-and-real-time-monitoring-89ab079f4360) to learn how we implemented the monitoring layer to compute the model's real-time performance.

## Install for Development

The batch prediction pipeline uses the training pipeline module as a dependency. Thus, as a first step, we must ensure that the training pipeline module is published to our private PyPi server.

**NOTE:** Make sure that your private PyPi server is running. Check the [Usage section](https://github.com/iusztinpaul/energy-forecasting#the-pipeline) if it isn't.

Build & publish the `training-pipeline` to your private PyPi server:
```shell
cd training-pipeline
poetry build
poetry publish -r my-pypi
cd ..
```

Install the virtual environment for `batch-prediction-pipeline`:
```shell
cd batch-prediction-pipeline
poetry shell
poetry install
```

Check the [Set Up Additional Tools](https://github.com/iusztinpaul/energy-forecasting#-set-up-additional-tools-) and [Usage](https://github.com/iusztinpaul/energy-forecasting#usage) sections to see **how to set up** the **additional tools** and **credentials** you need to run this project.

## Usage for Development

To start batch prediction script, run:
```shell
python -m batch_prediction_pipeline.batch
```

To compute the monitoring metrics based, run the following:
```shell
python -m batch_prediction_pipeline.monitoring
```

**NOTE:** Be careful to complete the `.env` file and set the `ML_PIPELINE_ROOT_DIR` variable as explained in the [Set Up the ML_PIPELINE_ROOT_DIR Variable](https://github.com/iusztinpaul/energy-forecasting#set-up-the-ml_pipeline_root_dir-variable) section of the main README.
risklab 1.0.2
Applied Quantiative (Portfolio) Risk Management
Requires Python: >=3.11
Keywords: backtesting, portfolio, quant, quantiative, risk

# RiskLab

Applied Quantiative (Portfolio) Risk Management

### Functions

- `scale_to_target_volatility()`: Create a signal to scale returns to a target (annualized) volatility.

- `backtest_signal()`: Create a vectorized backtest from a signal and the underlying returns.

- `backtest_portfolio()`: Create a vectorized backtest from a portfolio of weights and the underlying returns.


### Authors

[Unravel.finance](https://unravel.finance)

### Licence

MIT Licence
codafs 0.0.0
Python helpers for accessing Coda Distributed File System functionality.
Requires Python: >=3.7

# CodaFS Python helpers

Python helpers for the Coda Distributed File System.

Some wrappers around Coda command line interface tooling to make it easier to
access Coda specific information from the file system. Things like the unique
Coda FID (file identifier) and manipulating Coda ACLs (access control lists).

And a collection of Python scripts that use these wrappers to help with the
management of the file system.

* coda-make-certs is used to generate and update X509 certificates for Coda
  realms and servers.
* coda-sync-acls can be used to copy, backup and restore ACLs.
* coda-volmunge is a tool to walk a subtree of a volume to trigger the client
  to make sure all replicas are up-to-date and force server-server resolution
  in case of discrepancies. It can also be used to find unresolvable conflicts,
  missing volume mounts and other oddities.

This is a work in progress.

## Installation

```sh
pipx install codafs
```

## Development

```sh
git clone https://github.com/cmusatyalab/coda.git
cd coda/python
pipx install -e .
```

Rebuild the sdist and wheel packages with pyproject-build.

```sh
pipx install build
cd coda/python
pyproject-build
```

## Documentation / Manual pages

This documentation can be built using mkdocs-material.

```sh
pipx install mkdocs-material --install-deps
cd coda/python
mkdocs serve
```

The man pages under `coda/python/docs/manpages` can also be converted to UNIX
man pages using pandoc.

```sh
cd coda/python/docs/manpages
pandoc -s -t man filename.1.md > coda-filename.1
```
fatoriais 0.0.1
Calcula o fatorial de um número inteiro não negativo.
Requires Python: >=3.8

# fatoriais

Description. 
The package fatoriais is used to:
	- Calculate the factorials of numbers from 1 to 10

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install fatoriais

```bash
pip install fatoriais
```

## Usage

```python
from fatoriais.fatorial import fatorial
fatorial(n)
```
- Replace "n" with the number you want the factorial

## Author
Enzo Camelo Vieira

## License
[MIT](https://choosealicense.com/licenses/mit/)