semvec/pypi-packages huggingface dataset:
iflow-mcp_sshh12-mcp-demo 0.1.0
URL-Based MCP Server - A proof of concept stateless MCP server builder
Requires Python: >=3.8

# URL-Based MCP Server

> URL MCP is a proof of concept stateless MCP server builder that allows users to build MCP servers without writing or hosting code. It's intended for protocol and security experimentation rather than for building real world MCP integrations.

<img width="500" alt="Screenshot 2025-04-12 at 12 07 39 PM" src="https://github.com/user-attachments/assets/a9b25d5a-a950-4fdb-b789-90d637f6c142" />

## Usage

1. Go to https://url-mcp-demo.sshh.io/
2. Add custom tools to your MCP server

- If you want to hardcode tool responses, select "static text response"
- If you want dynamic HTTP-based responses, select "http post endpoint"
  - Typically I'll use a temp URL from https://webhook.site/ which logs all the requests and allows you to configure custom responses

3. Copy the `MCP Configuration` into your client of choice

## Local Hosting

There is not really a point to hosting this locally (the whole idea is that you can use this without hosting just with the URL) but in case you want to modify the app itself:

1. `cd backend && pip install requirements.txt && python main.py`

## Example: System Prompt Exfiltration

Create a custom MCP server for extracting the system prompt of an application.

1. Configure the tools to trick the client into trusting it. Use a https://webhook.site/ temp url for the tool response.
2. Copy the MCP config
3. In the client ask for an audit and the view the webhook logs.

| Step 1                                                                                                                                               | Step 2                                                                                                                                               | Step 3                                                                                                                                                |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| <img width="822" alt="Screenshot 2025-04-12 at 12 14 40 PM" src="https://github.com/user-attachments/assets/bee7fb56-c405-4260-82ef-e485555c19ae" /> | <img width="803" alt="Screenshot 2025-04-12 at 12 14 50 PM" src="https://github.com/user-attachments/assets/5a94ce4f-904d-4ee2-b117-e7147e877b56" /> | <img width="1222" alt="Screenshot 2025-04-12 at 12 15 00 PM" src="https://github.com/user-attachments/assets/d375f49e-6852-48d2-a502-dc6355530e22" /> |
tensorstore 0.1.81
Read and write large, multi-dimensional arrays
Requires Python: >=3.11

# TensorStore

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![PyPI](https://img.shields.io/pypi/v/tensorstore)](https://pypi.org/project/tensorstore)
[![Build](https://github.com/google/tensorstore/workflows/Build/badge.svg)](https://github.com/google/tensorstore/actions?query=workflow%3ABuild)
[![Docs](https://github.com/google/tensorstore/workflows/Docs/badge.svg)](https://google.github.io/tensorstore)


TensorStore is an open-source C++ and Python software library designed for
storage and manipulation of large multi-dimensional arrays that:

* Provides advanced, fully composable indexing operations and virtual views.

* Provides a uniform API for reading and writing multiple array formats, including
  [zarr](https://zarr.dev/) and [N5](https://github.com/saalfeldlab/n5).

* Natively supports multiple storage systems, such as local and network
  filesystems, [Google Cloud Storage](https://cloud.google.com/storage),
  Amazon S3-compatible object stores, HTTP servers, and in-memory storage.

* Offers an asynchronous API to enable high-throughput access even to
  high-latency remote storage.

* Supports read caching and transactions, with strong atomicity,
  isolation, consistency, and durability (ACID) guarantees.

* Supports safe, efficient access from multiple processes and machines via
  optimistic concurrency.

Documentation and installation instructions are at
<https://google.github.io/tensorstore>.


## Getting Started

To get started using the TensorStore Python API, you can install the tensorstore
PyPI package using:

```
pip install tensorstore
```

Refer to the [tutorials](https://google.github.io/tensorstore/python/tutorial.html)
and [API documentation](https://google.github.io/tensorstore/python/api/index.html),
or the announcement on the [Google Research Blog](https://ai.googleblog.com/2022/09/tensorstore-for-high-performance.html)
for more details.


This is not an officially supported Google product.

# License

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this software except in compliance with the License.
You may obtain a copy of the License at <http://www.apache.org/licenses/LICENSE-2.0>.

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
iflow-mcp_jamiew-spotify-mcp 0.2.0
MCP spotify project
Requires Python: >=3.11

# spotify-mcp MCP server

MCP server connecting Claude with Spotify. This fork of [varunneal/spotify-mcp](https://github.com/varunneal/spotify-mcp) adds smart-batching tools and advanced playlist features that optimize API usage.

## Features

### Core Functionality
- **Playback Control**: Start, pause, skip tracks, manage queue
- **Search & Discovery**: Find tracks, albums, artists, playlists with pagination  
- **Real-time State**: Live user profile and playback status

### Enhanced Playlist Tools (New in this fork)
- **Smart Batch Operations**: Add/remove up to 100 tracks in single API calls
- **Large Playlist Support**: Efficiently handle playlists with 1000+ tracks using pagination
- **Advanced Playlist Management**: Create, modify details, bulk track operations
- **API-Optimized Workflows**: Intelligent batching reduces API calls by 60-80%

## Installation

### 1. Get Spotify API Keys
1. Create account at [developer.spotify.com](https://developer.spotify.com/)
2. Create app with redirect URI: `http://localhost:8888`

### 2. Install the MCP Server
```bash
git clone https://github.com/jamiew/spotify-mcp.git
cd spotify-mcp
uv sync
```

### 3. Configure Claude Desktop
Add to Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
```json
"spotify": {
  "command": "uv",
  "args": ["--directory", "/path/to/spotify-mcp", "run", "spotify-mcp"],
  "env": {
    "SPOTIFY_CLIENT_ID": "YOUR_CLIENT_ID",
    "SPOTIFY_CLIENT_SECRET": "YOUR_CLIENT_SECRET",
    "SPOTIFY_REDIRECT_URI": "http://localhost:8888"
  }
}
```

**Requirements**: Spotify Premium account, `uv` >= 0.54

## Usage Examples

- **"Create a chill study playlist with 20 tracks"** → Search + playlist creation + bulk track addition
- **"Show me the first 50 tracks from my 'Liked Songs'"** → Pagination for large playlists  
- **"Find similar artists to Radiohead and add their top tracks to my queue"** → Search + artist info + queue management

## Development

Built with **FastMCP framework** featuring 13 focused tools, type-safe APIs, and comprehensive test coverage.

**Debug with MCP Inspector:**
```bash
npx @modelcontextprotocol/inspector uv --directory /path/to/spotify_mcp run spotify-mcp
```
fabric-jumpstart 0.1.1
Get started quickly with pre-built solutions, tutorials, demos, and accelerators—automated, high-quality, and open-source.
Requires Python: <=3.13,>=3.10

# ⚡️Fabric Jumpstart

Fabric Jumpstart accelerates Microsoft Fabric adoption with ready-to-run accelerators, demos, and tutorials that install directly into your workspace in minutes via [fabric-cicd](https://microsoft.github.io/fabric-cicd/latest/).

## What is a Jumpstart?
- A curated, tested Fabric solution (data, notebooks, pipelines, reports, supporting assets, etc.) that you can deploy end-to-end with one call.
- Each Jumpstart is self-contained: data is bundled or generated for you, and post-install notebooks guide any manual configuration.
- Discover available Jumpstarts at https://fabric.jumpstart.microsoft.com ( ⚠️ UNDER CONSTRUCTION ⚠️ ).

## Install the Library
Requirements: Python 3.10–3.12 and access to a Microsoft Fabric workspace.

```bash
pip install fabric-jumpstart
```

## List and Install a Jumpstart
Run inside a Fabric notebook (or any Python environment with Fabric credentials):

```python
import fabric_jumpstart as jumpstart

jumpstart.list()  # renders an interactive catalog

# Copy the install command from the catalog, past in another cell and run!
jumpstart.install("spark-structured-streaming")
```

Notes
- `workspace_id` is optional when you run in a Fabric notebook; it auto-detects the current workspace. Specify to deploy to another target workspace.
- `install()` accepts extras like `item_prefix` and `unattended=True` if you prefer console logs over HTML output.

## Handling Name Conflicts
If items with the same name already exist in your workspace, Fabric Jumpstart will detect conflicts and provide resolution options:

1. **Overwrite existing items**:
   ```python
   jumpstart.install("spark-structured-streaming", overwrite=True)
   ```

2. **Auto-generate a prefix** to avoid conflicts:
   ```python
   jumpstart.install("spark-structured-streaming", auto_prefix_on_conflict=True)
   ```
   This generates a prefix like `js3_sss__` (jumpstart ID + abbreviated name) and applies it to all deployed items.

3. **Provide a custom prefix**:
   ```python
   jumpstart.install("spark-structured-streaming", item_prefix="demo_")
   ```

The prefixing strategy:
- Renames item directories (e.g., `MyNotebook.Notebook` → `js3_sss__MyNotebook.Notebook`)
- Updates all references to renamed items within configuration files
- Uses word-boundary matching to avoid double-prefixing if you re-run the same install
- Reuses existing prefixes from previous attempts to prevent `js3_sss__js3_sss__` patterns

## Contributing
Please follow the contribution process in [CONTRIBUTING.md](CONTRIBUTING.md) and the coding expectations in [STANDARDS.md](STANDARDS.md).

## Learn More
- Explore jumpstarts and documentation: https://fabric.jumpstart.microsoft.com
- Package metadata and source code live in this repository under `src/fabric_jumpstart/`.
tikzpics 0.1.3
Python interface to generate (readable) Tikz figures.
Requires Python: >=3.8
Keywords: python

# tikzpics

Python interface to generate (readable) Tikz figures.

# Install

Create and activate python environment, then install `tikzpics` with

```
pip install tikzpics
```

# Examples

## Generate tikz-figures with Python API

```python
fig = TikzFigure()

n1 = fig.add_node(0, 0, shape="circle", color="white", fill="blue", content="Hello!")
n2 = fig.add_node(5, 0, shape="circle", color="white", fill="red", content="Hi!")

fig.draw([n1, n2], options=["->", "line width=2"], color="gray")

fig.show()
```

Note that to visualize the plots in a popup or in jupyterlab, install with `pip install "tikzpics[vis]"`

## IPython Magic Commands

tikzpics includes IPython magic commands for compiling TikZ figures directly in Jupyter notebooks!

Load the extension:
```python
%load_ext tikzpics.ipython
```

Then use the `%%tikz` cell magic:
```tikz
%%tikz
\begin{tikzpicture}
\draw[thick, blue] (0,0) circle (2cm);
\node at (0,0) {Hello TikZ!};
\end{tikzpicture}
```

See [tutorials](https://max-models.github.io/tikzpics/tutorials) for more examples!
spadix-cli 0.7.7
A friendly wrapper for colcon
Requires Python: >=3.8
Keywords: spadix-cli

# Spadix, a friendly wrapper for `colcon`

Copyright (C) 2021-2024 SafeAI

Copyright (C) 2025 Pronto.AI

## Why?

Our company uses
[`colcon` (from collective construction build manager)](https://colcon.readthedocs.io/en/released/)
as our main build management tool for many years.

While we like this package, it has its problem areas, in our opinion, especially when used by
unexperienced engineers.

- Default build is not a merged one, and this disables Doxygen build
- It is allowed to run from any directory in the project tree, making the tree contaminated with
build artifacts
- By default console output is switched off and switching it back on requires an additional parameter
- It requires few additional parameters to run `gtest` alone

We decided to fix these deficiencies and created a wrapper `spadix` around `colcon`.
Catkin, ament, colcon, spadix... Got it?

## How

`spadix` accepts all `colcon` commands and options plus it adds and modifies few commands on its own.

Usage:

```sh
spadix [Global options] [command] [command options] ...

[Global options]
--no-merge  : Do not use --merge-install option for colcon
--no-console  : Do not use the default console mode: `--event-handlers console_cohesion+`
--no-root-check  : Do not check that spadix being started from the root of a git project
--ninja  : Use Ninja for building when available
--non-ninja  : Do not use Ninja for building, even if it is available

Commands:
clean  :Clean all projects (essentially executes `rm -rf log install build`)
clean:<project1>[,<project2>...]  :Clean selected, comma-separated projects. Spaces not supported

build  :Build all projects using --merge-install settings
build:<project1>[,<project2>...]  Build selected, comma-separated projects. Spaces not supported
    Build options:
        --release   : RelWithDebInfo (debug build by default)
        --no-fif    : Disable Failure Injection Framework (FIF enabled by default)

test  :Test all projects using --merge-install settings
test:<project1>[,<project2>...]  :Test selected, comma separated projects

gtest:<project> [gtest parameters]  :Run gtest only ('build/test_<project name>')
```
FAST-OAD-CS25 0.8.1
FAST-OAD_CS25 is a FAST-OAD plugin with CS25/FAR25-related models.
Requires Python: <3.15,>=3.10
Keywords: aircraft, design, multi-disciplinary

<p align="center">
  <img src="https://github.com/fast-aircraft-design/FAST-OAD/blob/master/docs/img/FAST_OAD_logo2.jpg?raw=true" alt="FAST-OAD logo" width="600">
</p>

# CS-25/FAR-25-related models


[![image](https://img.shields.io/pypi/v/fast-oad-cs25.svg)](https://pypi.python.org/pypi/fast-oad-cs25)
[![image](https://img.shields.io/pypi/pyversions/fast-oad-cs25.svg)](https://pypi.python.org/pypi/fast-oad-cs25)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

![Tests](https://github.com/fast-aircraft-design/FAST-OAD_CS25/workflows/Tests/badge.svg)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/06d1fb8ee5c3429cb3cbb165413187bc)](https://app.codacy.com/gh/fast-aircraft-design/FAST-OAD_CS25/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)[![codecov](https://codecov.io/gh/fast-aircraft-design/FAST-OAD_CS25/branch/main/graph/badge.svg?token=91CIX996RD)](https://codecov.io/gh/fast-aircraft-design/FAST-OAD_CS25)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

[![Documentation Status](https://readthedocs.org/projects/fast-oad-cs25/badge/?version=stable)](https://fast-oad-cs25.readthedocs.io/)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/fast-aircraft-design/FAST-OAD_CS25.git/latest-release?urlpath=lab%2Ftree%2Fsrc%2Ffastoad_cs25%2Fnotebooks)


This package is a plugin for FAST-OAD (version 1.3 or above). It contains models related to classic
commercial transport aircraft.

## Want to try quickly?

You can run FAST-OAD-CS25 notebooks **without installation** using our
[Binder-hosted Jupyter notebooks](https://mybinder.org/v2/gh/fast-aircraft-design/FAST-OAD_CS25.git/latest-release?filepath=src%2Ffastoad_cs25%2Fnotebooks).


## Install

**Prerequisite**: FAST-OAD-CS25 needs at least **Python 3.10**.

It is recommended (but not required) to do the install in a virtual
environment ([conda](https://docs.conda.io/en/latest/),
[venv](https://docs.python.org/3.12/library/venv.html), ...)

Once Python is installed, installation can be done using pip. FAST-OAD, the core software, will be
installed at the same time.

> **Note**: If your network uses a proxy, you may have to do [some
> settings](https://pip.pypa.io/en/stable/user_guide/#using-a-proxy-server)
> for pip to work correctly

You can install the latest version (including the main software FAST-OAD) with this command:

``` {.bash}
$ pip install --upgrade fast-oad-cs25
```
wheel-stub 0.5.0
wheel stub package build backend
Requires Python: >=3.8

# wheel-stub

This is a PEP 517 build backend to act as a "soft link" between a package released on a 3rd party package index and pypi.org. This allows users to keep the simple UX of `pip install foo` while hosting the actual wheel files on a non-PyPi index.

## Demo usage

1. Install hatch: https://hatch.pypa.io/latest/install/
2. Run `hatch shell`
3. Run `hatch build -t wheel`
4. `cd demo`
5. Grab your favorite wheel file on https://pypi.nvidia.com, e.g.
   ```
   wget https://pypi.nvidia.com/nvidia-cuda-runtime-cu12/nvidia_cuda_runtime_cu12-12.4.99-py3-none-manylinux2014_x86_64.whl
   ```
6. Build the sdist:
   ```
   PIP_FIND_LINKS=`pwd`/../dist PIP_NO_INDEX=1 python -m build --sdist --config-setting source_wheel=nvidia_cuda_runtime_cu12-12.4.99-py3-none-manylinux2014_x86_64.whl
   ```
   There should now be a new `dist/` folder with e.g. `nvidia_cuda_runtime_cu12-12.4.99.tar.gz`
8. Install the sdist:
   ```
   pip install --no-cache ./dist/<my_sdist>.tar.gz
   ```
   Feel free to test with `--extra-index-url https://pypi.nvidia.com` as well.
9. Done! You should see everything install correctly

## Configuration

There are a few configuration options available for `wheel_stub`. These can be set in your `pyproject.toml` file:

- `index_url`: The url to the 3rd party index to install wheels from. This is the only required configuration setting.

- `stub_only`: Do not install the wheel from the 3rd party package repository, instead erroring with instructions of how to use the repository directly. This can be used in cases such as a project which depends on non-PyPi dependencies, which would get rejected from pypi.org. Set automatically based on project dependencies. `true` or `false` (default `false`)

- `include_cuda_debuginfo`: Whether to query information about the available CUDA runtime when reporting an error. `true` or `false` (default `false`)

## License

This project is released under the Apache-2 license. It vendors the `packaging` project, which is BSD 2-clause and Apache 2 dual licensed. It also vendors `tomli`, which is MIT licensed. For more details see the [LICENSE](/LICENSE) file.