semvec/pypi-packages huggingface dataset:
mdformat-yamlfmt 0.0.1
Mdformat plugin to format yaml code blocks using yamlfmt.
Requires Python: >=3.7

# Mdformat yamlfmt

Mdformat plugin to format yaml code blocks using [yamlfmt](https://github.com/google/yamlfmt).

## Installation

The package is available on PyPI [here](https://pypi.org/project/mdformat-yamlfmt/), you can install it with:

```bash
pip install mdformat-yamlfmt
```
yt-dlp-mcp 0.2.0
MCP server for YouTube video operations using yt-dlp
Requires Python: >=3.8
Keywords: mcp, youtube, yt-dlp, video, transcription

# yt-dlp MCP Server

A Model Context Protocol (MCP) server that provides YouTube video operations using yt-dlp.

## Features

- **Get Transcriptions**: Extract transcriptions from YouTube videos with optional timestamp preservation
- **Search Videos**: Search for YouTube videos by terms and return URLs
- **List Channel Videos**: Get recent videos from a YouTube channel

## Installation

```bash
pip install -e .
```

## Usage

Run the MCP server:

```bash
yt-dlp-mcp
```

## Tools

### get_transcription
- **Input**: YouTube URL, optional timestamp preservation flag
- **Output**: Video transcription text

### search_videos
- **Input**: Search terms
- **Output**: List of YouTube video URLs

### list_channel_videos
- **Input**: Channel name/URL, number of videos to return
- **Output**: List of recent video URLs from the channel

## Requirements

- Python 3.8+
- yt-dlp
- fastmcp
- youtube-search-python
ms365sync 0.3.4
A Python library for syncing files between Microsoft 365 SharePoint and local storage
Requires Python: >=3.8
Keywords: microsoft, office365, sharepoint, sync, graph-api

# MS365Sync

Sync files between Microsoft 365 SharePoint and your local machine with permission tracking.

## What it does

- Downloads files from SharePoint document libraries to local folders
- Tracks file permissions and detects changes
- Syncs only when files are modified (smart sync)
- Works via command line or Python code

## Quick Start

### 1. Install

```bash
pip install ms365sync
```

### 2. Setup Azure App

1. Go to [Azure Portal](https://portal.azure.com) → Azure Active Directory → App registrations
2. Create new app registration
3. Add these API permissions: `Sites.Read.All`, `Files.Read.All` (Application permissions)
4. Create a client secret
5. Grant admin consent

### 3. Configure

Create a `.env` file:

```env
TENANT_ID=your-azure-tenant-id
CLIENT_ID=your-azure-client-id
CLIENT_SECRET=your-azure-client-secret
```

### 4. Use it

**Command line:**
```bash
ms365sync \
  --sharepoint-host "yourcompany.sharepoint.com" \
  --site-name "Your Site Name" \
  --doc-library "Documents"
```

**Python code:**
```python
from ms365sync import SharePointSync

sync = SharePointSync(
    sharepoint_host="yourcompany.sharepoint.com",
    site_name="Your Site Name", 
    doc_library="Documents"
)

changes = sync.sync()
print(f"Synced {changes['total_files']} files")
```

## What you get

After running sync:
```ms365_data/
├── data/               # Your SharePoint files
└── .permissions.json   # Permission tracking
sync_logs/              # Sync operation logs
```

## Need help?

- Check the `examples/` folder for more usage patterns
- Report issues: [GitHub Issues](https://github.com/Phi4AI/ms365sync/issues)
- Email: aiteam@phianalytica.com
live-cells-py 0.2.0
A reactive programming library for Python ported from Live Cells for Dart
Requires Python: >=3.6

# Live Cells Python

**This software is still in beta, and will likely experience rapid
changes before the first official release.**

Live Cells Python is a reactive programming library for Python, ported
from [Live Cells](https://livecells.viditrack.com/) for Dart.

## Installation

Run the following command to install Live Cells Python:

```sh
pip install live-cells-py
```

## Examples

**This section contains examples demonstrating the main features of
the library. Head to the
[documentation](https://alex-gutev.github.io/live_cells_py/index.html),
for more information on how to use this library.**

The basic building block of Live Cells is the cell, which is an object
with a value and a set of observers, which react to changes in the
value.

Cells are defined as follows:

```python
import live_cells as lc

a = lc.mutable(0)
a = lc.mutable(0)
```

And are observed as follows:

```python
lc.watch(lambda: print(f'{a()}, {b()}'))
```

The *watch function* defined above prints the values of the cells `a`
and `b` to standard output. It is called whenever the value of `a` or
`b` changes.

For example the following code, which sets the values of `a` and `b`:

```python
a.value = 1
b.value = 2
a.value = 3
```

Results in the following being printed to standard output:

```
1, 0
1, 2
3, 2
```

Watch functions comprising multiple statements can be defined using
the decorator of `watch`:

```python
@lc.watch
def watcher():
    print(f'A = {a()}')
    print(f'B = {b()}')
```

Cells can also be defined as a function of the values of one or more
cells. For example the following cell is defined as the sum of cells
`a` and `b`:

```python
c = lc.computed(lambda: a() + b())
```

The value of cell `c` is recomputed automatically whenever the value
of either `a` or `b` changes.

This cell can also be defined more succinctly as an expression of cells:

```python
c = a + b
```

That looks exactly like a normal variable definition.

This can be used to run a routine automatically whenever a certain
condition is met. For example, let's print a message to standard
output whenever the sum exceeds 100:

```python
@lc.watch
def watch_sum():
    if c() > 100:
        print('Sum exceeds 100!!!')
```

When the following is executed:

```python
a.value = 90
b.value = 30
```

The following message is printed to standard output automatically:

```
Sum exceeds 100!!!
```
textual-colorpicker 0.1.0
A color picker widget for Textual
Requires Python: >=3.8

# textual-colorpicker

A color picker widget for [Textual](https://github.com/Textualize/textual).

![screenshot](https://raw.githubusercontent.com/TomJGooding/textual-colorpicker/main/assets/screenshot.png)

## Installation

Install textual-colorpicker using pip:

```
pip install textual-colorpicker
```

## Usage

textual-colorpicker provides a `ColorPicker` widget for use in Textual.

```python
from textual.app import App, ComposeResult

from textual_colorpicker import ColorPicker


class ColorPickerApp(App):
    CSS = """
    Screen {
        align: center middle;
    }
    """

    def compose(self) -> ComposeResult:
        yield ColorPicker()


if __name__ == "__main__":
    app = ColorPickerApp()
    app.run()
```

## Limitations

Textual apps run in the terminal, which work in terms of character cells rather
than pixels. This means you obviously can't have the same fine-grained control
with the mouse for this color picker as usual.

## Contributing

I created this color picker widget as a learning exercise to better understand
Textual and it is still a work in progress.

I'd really appreciate any feedback or suggestions, but I'm afraid I probably
won't be accepting any PRs at the moment.

## License

Licensed under the [GNU General Public License v3.0](LICENSE).
coderouter 0.1.0
A simple routing library
Requires Python: >=3.7

# CodeRouter

A simple routing library for Python applications.

## Installation

```bash
pip install coderouter
```

## Usage

```python
from coderouter import Router

router = Router()

def home_handler():
    return "Welcome home!"

def about_handler():
    return "About page"

router.add_route("/", home_handler)
router.add_route("/about", about_handler, methods=["GET", "POST"])

# Handle requests
result = router.handle("/")  # Returns "Welcome home!"
result = router.handle("/about", "POST")  # Returns "About page"
```

## License

MIT
obsarray 1.0.3
Measurement data handling in Python
Requires Python: >=3.8

# obsarray: Measurement uncertainty handling in Python

[![Build Status](https://app.travis-ci.com/comet-toolkit/obsarray.svg?branch=main)](https://app.travis-ci.com/comet-toolkit/obsarray)
[![codecov](https://codecov.io/gh/comet-toolkit/obsarray/branch/main/graph/badge.svg?token=PZTGG03VQY)](https://codecov.io/gh/comet-toolkit/obsarray)
[![Documentation Status](https://readthedocs.org/projects/obsarray/badge/?version=latest)](https://obsarray.readthedocs.io/en/latest/?badge=latest)

**obsarray** is an extension to [xarray](https://docs.xarray.dev/en/stable/) for defining, storing and interfacing with uncertainty information using standardised metadata. It is particularly designed to work well with [netCDF](https://www.unidata.ucar.edu/software/netcdf/) files and for the Earth Observation community.

obsarray is part of the [CoMet Toolkit](https://www.comet-toolkit.org) (community metrology toolkit), and can combined with the [punpy](https://punpy.readthedocs.io/en/latest/) (propagating uncertainties in python) module for very simple propagation of defined data uncertainties through arbitrary python functions.

## Installation

obsarray is installable via pip.

## Documentation

For more information visit our [documentation](https://obsarray.readthedocs.io/en/latest).

## License

obsarray is free software licensed under the
[GNU Public License (v3)](./LICENSE).

## Acknowledgements

obsarray has been developed by [Sam Hunt](https://github.com/shunt16).

The development has been funded by:

* The UK's Department for Business, Energy and Industrial Strategy's (BEIS) National Measurement System (NMS) programme
* The IDEAS-QA4EO project funded by the European Space Agency.

## Project status

obsarray is under active development. It is beta software.