semvec/pypi-packages huggingface dataset:
readydata-sdk-py 0.1.7
Python SDK for ReadyData asset management
License: MIT
Requires Python: >=3.9

# ReadyData Python SDK

Python SDK for ReadyData asset management with cross-language validation consistency.

## Installation

```bash
pip install readydata-sdk-py
```

## Usage

```python
from readydata import AssetClient, MemoryAdapter

# Create client with in-memory adapter
client = AssetClient(MemoryAdapter())

# Store an asset
await client.put('s3://bucket/asset.jpg', asset_data)

# Retrieve an asset  
asset = await client.get('s3://bucket/asset.jpg')

# List all assets
uris = await client.list()
```

## Features

- **Type Safety**: Pydantic models with full validation
- **Cross-Language**: Compatible with TypeScript SDK
- **Extensible**: Support for meta fields and structured extensions
- **Validation**: Registry-driven extension validation
- **Testing**: Comprehensive test suite with golden examples

## Asset Types

- **Image**: JPEG, PNG, WebP, SVG with dimensions and size limits
- **Document**: PDF, DOCX, TXT, HTML, MD with page counts and language detection  
- **Dataset**: CSV, JSON, Parquet, Arrow with row/column counts and schema information

## Development

```bash
# Install in development mode
pip install -e ".[dev]"

# Run tests
pytest tests/ -v

# Type checking
mypy src/readydata/
```

Part of the ReadyData cross-language SDK foundation.
fastapi-blocks 0.1.5
A library for creating modular FastAPI applications.
License: MIT
Requires Python: >=3.11

# FastAPI Blocks

[![PyPI version](https://badge.fury.io/py/fastapi-blocks.svg)](https://badge.fury.io/py/fastapi-blocks)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/release/python-311/)
![Tests](https://github.com/r3sbarra/fastapi-blocks/actions/workflows/python-tests.yml/badge.svg)


`fastapi-blocks` is a Python package that allows you to structure your FastAPI applications using a modular "blocks" architecture. Each block is a self-contained component with its own routes, static files, and templates. This makes it easy to develop and maintain large FastAPI applications by breaking them down into smaller, reusable pieces.

## Installation

```bash
pip install fastapi-blocks
```

Then run
```bash
python -m fastapi_blocks setup -f BLOCKS_FOLDER
```
*Replace `BLOCKS_FOLDER` with path to blocks folder from root

### Updating blocks

```bash
python -m fastapi_blocks update
```

Additional flags:
- -A - Auto-install pip packages from blocks
- -S - Save block hashes
- -V - Do not verify block hashes (Default is to verify)

## Examples

### Example Block
- [Example Block](https://github.com/r3sbarra/fablocks-example-block) - An example block

### Example Project
- [Example Project](https://github.com/r3sbarra/fablocks-example-project) - An example project

## Reserved Words

### Variable names
- `router` - In router files, the variable router is used to searche for router to include into app.

### Template names
- 

## How to

### Register Jinja funcs for shared templates
In order to allow other blocks to access functions via jinja, you would need to add the functions via hook into `BlockManager().templates_globals`, the key being the name of the function to call from jinja, and the value being the function itself.

eg.
```python
def register_jinja_funcs(**kwargs):
    from fastapi_blocks import BlockManager
    BlockManager().templates_globals['has_role'] = has_role

class Settings(BlockSettingsMixin):
    
    additional_user_roles : Optional[List[str]] = Field(description="Additional user roles to add", default=None)

    def _start_hooks(self) -> List:
        return super()._start_hooks() + [register_jinja_funcs]
```

Then, make sure that the block_config.toml has an entry for `extra_block_settings` with the name of the python file as value. .ie for 'settings.py', it would be settings.

Once that is done, you will need to run setup so that the blockmanager toml is updated.

In some other block, you would then be able to call the function from jinja as long as it is using `templates` from BlockManager.

If you want to use jinja within a blocks jinja2env, you'd have to get the template_globals from blockmanager then add them to the jinja2env's globals.

## Todo:

- [ ] Put more meaningful tests
- [ ] Add command to setup templates/default
- [ ] Add todos
- [ ] Add some sort of security check
stash-mcp 1.2.0
A Model Context Protocol (MCP) server for Stash issue analysis and task management
License: MIT
Requires Python: >=3.10
Keywords: ai, claude-code, copilot, cursor, issue-analysis, llm, mcp, model-context-protocol, stash, task-management

# Stash MCP Server

[![PyPI version](https://badge.fury.io/py/stash-mcp.svg)](https://badge.fury.io/py/stash-mcp)
[![Python versions](https://img.shields.io/pypi/pyversions/stash-mcp.svg)](https://pypi.org/project/stash-mcp/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Model Context Protocol (MCP) server for Stash issue analysis. This server enables AI assistants to interact with your Stash instance to analyze issues, find similar content, and identify subject matter experts.

## Features

- **Issue Analysis**: Get detailed analysis for specific issues including similar content discovery
- **Task Management**: List and manage tasks assigned to the authenticated user
- **Secure Authentication**: Uses MCP tokens for secure API access

## Configuration

The server requires the following environment variables:

- `STASH_API_BASE`: Base URL for your Stash API
- `STASH_MCP_TOKEN`: Your Stash MCP authentication token

You can get these environment variables from your [Stash account](https://usestash.com).

### With Copilot, Cursor, or Claude Code

Add this to your IDE MCP configuration file:

```json
{
  "mcpServers": {
    "stash": {
      "command": "uvx",
      "args": ["stash-mcp"],
      "env": {
        "STASH_API_BASE": "stash-api-base-url",
        "STASH_MCP_TOKEN": "your-mcp-token-here"
      }
    }
  }
}
```

### Available Tools

#### `list_my_tasks`

Lists all tasks assigned to the authenticated user, grouped by categories.

#### `get_issue_analysis`

Get detailed analysis for a specific issue including:

- Similar issues
- Related documents
- Relevant code files
- Subject matter experts

## Requirements

- Python 3.10 or higher
- Valid [Stash account](https://usestash.com) with MCP access
- Network access to your Stash instance

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

For support and questions, See [Stash Documentation](https://docs.usestash.com/mcp/stash-mcp).