semvec/pypi-packages huggingface dataset:
flx4py 0.0.0b0
Python MIDI interface for the Pioneer DDJ-FLX4, providing high-level access to buttons, knobs, and LEDs.
Requires Python: >=3.10
Keywords: midi, dj, controller, pioneer, ddj-flx4

# flx4py
Python MIDI interface for the Pioneer DDJ-FLX4, providing high-level access to buttons, knobs, and LEDs.
iflow-mcp_davidshtian-mcp-on-aws-bedrock 0.1.0
A simple and clear example for implementation and understanding Anthropic MCP (on AWS Bedrock)
Requires Python: >=3.10

# MCP on AWS Bedrock
A simple and clear example for implementation and understanding Anthropic MCP (on AWS Bedrock).

<a href="https://glama.ai/mcp/servers/cuhom1oc17">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/cuhom1oc17/badge" />
</a>

> For multiple MCP servers management, [this tiny project Q-2001](https://github.com/davidshtian/Q-2001) could be referred~

## Overview
This project demonstrates how to implement and use Anthropic's Model Context Protocol (MCP) with AWS Bedrock. It provides a client implementation that can interact with MCP-enabled tools through AWS Bedrock's runtime service.

## Updates 2025-05-10: Streamable HTTP

- Add support for [Streamable HTTP](https://github.com/modelcontextprotocol/python-sdk/releases/tag/v1.8.0)
- Rewrite the URL fetching MCP server `fetch_url_mcp_server.py` that demonstrates different transport types

### Usage Instructions

Run the server with default stdio settings (no transport parameter):
```bash
uv run fetch_url_mcp_server.py

# client
uv run client_stdio.py
```

Run with streamable-http transport on default port (8000):
```bash
python fetch_url_mcp_server.py --transport streamable-http

# client
uv run client_streamablehttp.py
```

Run with streamable-http transport on custom port:
```bash
python fetch_url_mcp_server.py --transport streamable-http --port 8080
```

## Prerequisites
- Python 3.10 or higher
- AWS account with Bedrock access
- Configured AWS credentials
- UV package manager

## Features
- Seamless integration with AWS Bedrock runtime using Converse API
- Tool format conversion for Bedrock compatibility
- Asynchronous communication handling
- Structured logging for debugging

## Contributing
Feel free to submit issues and pull requests to improve the implementation.

## License
MIT License

## References
- [Anthropic MCP](https://modelcontextprotocol.io/)
- [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
- [AWS Bedrock](https://aws.amazon.com/bedrock/)
download-flow-enmu 0.1.3
A task flow management tool for syncing todo files with taskwarrior
Requires Python: >=3.10

# tflow

A task flow management tool for syncing todo files with taskwarrior.

## Installation

### Development Installation (Editable Mode)

Install the package in editable mode so you can use the `tflow` command anywhere:

```bash
# In the project directory
pip install -e .
```

### Regular Installation

```bash
pip install .
```

## Usage

After installation, you can use the `tflow` command directly:

```bash
# Show available commands
tflow --help

# Read and import tasks from todo files
tflow read -c /path/to/files.yaml

# Modify tasks
tflow modfiy -a "new_data" -c "command"
```

## Configuration

Create a `files.yaml` configuration file to specify your todo file locations:

```yaml
sources:
  - id: "project1"
    type: "static"
    path:
      darwin: "/path/to/project1.todo"
      wsl: "/mnt/path/to/project1.todo"
  - id: "daily"
    type: "daily"
    path:
      darwin: "/path/to/agenda/todo"
      wsl: "/mnt/path/to/agenda/todo"
```

## Development

```bash
# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -e ".[dev]"

# Run tests
pytest
```

## Requirements

- Python >= 3.10
- taskwarrior installed on your system
hiveio-api 1.28.6rc3
Hive JSON-RPC API client package with lazy-loaded submodules for all Hive APIs
Requires Python: <4,>=3.12

## Hive JSON-RPC API Package

A unified Python package providing lazy-loaded clients for all Hive blockchain JSON-RPC APIs.

### Installation

```bash
pip install hiveio-api
```

### Available APIs

- `account_by_key_api` - AccountByKeyApi
- `account_history_api` - AccountHistoryApi
- `block_api` - BlockApi
- `bridge` - Bridge
- `condenser_api` - CondenserApi
- `database_api` - DatabaseApi
- `debug_node_api` - DebugNodeApi
- `follow_api` - FollowApi
- `jsonrpc` - Jsonrpc
- `hive` - Hive
- `market_history_api` - MarketHistoryApi
- `network_broadcast_api` - NetworkBroadcastApi
- `rc_api` - RcApi
- `reputation_api` - ReputationApi
- `search_api` - SearchApi
- `tags_api` - TagsApi
- `transaction_status_api` - TransactionStatusApi


### Usage

```python
from wax import create_hive_chain
from hiveio_api.database_api import DatabaseApi

class MyApiCollection:
    def __init__(self):
        self.database_api = DatabaseApi

chain = create_hive_chain().extends(MyApiCollection)
```

### Lazy Loading

Each API submodule is lazily loaded, meaning importing `hiveio_api` does not load all APIs into memory. Only the APIs you explicitly import are loaded:

```python
# Only loads database_api module
from hiveio_api.database_api import DatabaseApi

# Or access via the main package (still lazy)
from hiveio_api import database_api
```

### Running Examples

Each API includes an example that can be run as a module:

```bash
python3 -m hiveio_api.database_api
python3 -m hiveio_api.condenser_api
python3 -m hiveio_api.rc_api
```
django-bootstrap5 26.2
Bootstrap 5 for Django
Requires Python: >=3.10
Keywords: django, bootstrap, bootstrap5

# django-bootstrap5

[![CI](https://github.com/zostera/django-bootstrap5/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/zostera/django-bootstrap5/actions/workflows/ci.yml)
[![Coverage Status](https://coveralls.io/repos/github/zostera/django-bootstrap5/badge.svg?branch=main)](https://coveralls.io/github/zostera/django-bootstrap5?branch=main)
[![Latest PyPI version](https://img.shields.io/pypi/v/django-bootstrap5.svg)](https://pypi.python.org/pypi/django-bootstrap5)

Bootstrap 5 for Django.

## Goal

The goal of this project is to seamlessly blend Django and Bootstrap 5.

## Status

Ready for production. Issues and pull requests welcome, see [CONTRIBUTING.md](CONTRIBUTING.md).

## Requirements

This package requires a combination of Python and Django that is currently supported.

See "Supported Versions" on https://www.djangoproject.com/download/.

This package uses [uv](https://github.com/astral-sh/uv) and [just](https://github.com/casey/just) for local development.

## Documentation

The full documentation is at https://django-bootstrap5.readthedocs.io/

## Installation

1. Install using pip:

    ```console
    pip install django-bootstrap5
    ```

2. Add to `INSTALLED_APPS` in your `settings.py`:

   ```python
   INSTALLED_APPS = (
       # ...
       "django_bootstrap5",
       # ...
   )
   ```

3. In your templates, load the `django_bootstrap5` library and use the `bootstrap_*` tags. See example below.

## Example template

```jinja2
{% load django_bootstrap5 %}

<form action="/url/to/submit/" method="post" class="form">
    {% csrf_token %}

    {% bootstrap_form form %}

    {% bootstrap_button button_type="submit" content="OK" %}
    {% bootstrap_button button_type="reset" content="Cancel" %}
</form>
```

## Example app

An example app is provided in the folder `example`. You can run the example app with this command:

```console
just example
```

## Bugs and suggestions

If you have found a bug or if you have a request for additional functionality, please use the issue tracker on GitHub.

https://github.com/zostera/django-bootstrap5/issues

## License

You can use this under BSD-3-Clause. See [LICENSE](LICENSE) file for details.

## Author

Developed and maintained by [Zostera](https://zostera.nl).

Original author: [Dylan Verheul](https://github.com/dyve).

Thanks to everybody that has contributed pull requests, ideas, issues, comments and kind words.

Please see [AUTHORS](AUTHORS) for a list of contributors.
chronostrace-python 0.2.1
A beautiful time-travel debugger for Python: track variable changes line-by-line.
Requires Python: >=3.8

\# ChronosTrace 🚀



ChronosTrace is a tiny, beautiful "time-travel" debugger for Python. 

Just add a decorator to any function to see a line-by-line breakdown of variable changes and execution time.



\## Installation

```bash

pip install chronostrace

Usage

Python



from chronostrace import chronos



@chronos

def my\_function(n):

&nbsp;   total = 0

&nbsp;   for i in range(n):

&nbsp;       total += i

&nbsp;   return total



my\_function(3)

text





---



\### Step 3: Configure `pyproject.toml`

This is the most important part for PyPI. Open your `pyproject.toml` and update the `\[project]` section. It should look something like this:



```toml

\[project]

name = "chronostrace-pro"  # Or something unique to you

version = "0.1.0"

description = "A time-traveling state logger for Python functions"

authors = \[

&nbsp;   { name = "Your Name", email = "your@email.com" }

]

dependencies = \[

&nbsp;   "rich>=13.0.0",

]

readme = "README.md"

requires-python = ">=3.8"



\[build-system]

requires = \["setuptools>=61.0"]

build-backend = "setuptools.build\_meta"



\[tool.setuptools.packages.find]

where = \["src"]