semvec/pypi-packages huggingface dataset:
maxminconquer 0.1.4
A package to find the max and min values using divide and conquer.
Requires Python: >=3

# MaxMinConquer
        
        `maxminconquer` is a Python package that implements divide and conquer algorithms for finding the maximum and minimum values in a list.
        
        ## Functions
        
        - `find_max(arr, left, right)` - Finds the maximum value using divide and conquer.
        - `find_min(arr, left, right)` - Finds the minimum value using divide and conquer.
        
        ## Time Complexity
        
        - Both `find_max` and `find_min` functions have a time complexity of **O(n)** where **n** is the number of elements in the array. This is because in each step, the array is split into two halves, and the maximum or minimum value is recursively calculated on each half.
        
        ## Usage
        
        ```python
        from maxminconquer import find_max, find_min
        
        arr = [1, 2, 3, 4, 10, 90, -4, 5, 65, 87, 78, 98, 41]
        
        max_value = find_max(arr, 0, len(arr) - 1)
        print("Maximum value:", max_value)
        
        min_value = find_min(arr, 0, len(arr) - 1)
        print("Minimum value:", min_value)
orange-mcp-python 0.1.4
MCP server providing a Python REPL with persistent session
Requires Python: >=3.10
Keywords: mcp, python, repl, server

# Python REPL MCP Server

> This is a fork of [hdresearch/mcp-python](https://github.com/hdresearch/mcp-python), a Python REPL server for MCP protocol.

This MCP server provides a Python REPL (Read-Eval-Print Loop) as a tool. It allows execution of Python code through the MCP protocol with a persistent session.

## Setup

No setup needed! The project uses `uv` for dependency management.

## Environment Variables

The server supports `.env` file for environment variables management. Create a `.env` file in the root directory to store your environment variables. These variables will be automatically loaded and accessible in your Python REPL session using:

```python
import os

# Access environment variables
my_var = os.environ.get('MY_VARIABLE')
# or
my_var = os.getenv('MY_VARIABLE')
```

## Running the Server

Simply run:

```bash
uv run src/python_repl/server.py
```

## Usage with Claude Desktop

Add this configuration to your Claude Desktop config file:

```json
{
  "mcpServers": {
    "python-repl": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/python-repl-server",
        "run",
        "mcp_python"
      ]
    }
  }
}
```

The server provides three tools:

1. `execute_python`: Execute Python code with persistent variables

   - `code`: The Python code to execute
   - `reset`: Optional boolean to reset the session

2. `list_variables`: Show all variables in the current session

3. `install_package`: Install a package from pypi

## Examples

Set a variable:

```python
a = 42
```

Use the variable:

```python
print(f"The value is {a}")
```

List all variables:

```python
# Use the list_variables tool
```

Reset the session:

```python
# Use execute_python with reset=true
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request. Here are some ways you can contribute:

- Report bugs
- Suggest new features
- Improve documentation
- Add test cases
- Submit code improvements

Before submitting a PR, please ensure:

1. Your code follows the existing style
2. You've updated documentation as needed
3. Maybe write some tests?

For major changes, please open an issue first to discuss what you would like to change.
orange-typecast-api-mcp-server 0.1.0
MCP Server for typecast-api
Requires Python: >=3.12

# typecast-api-mcp-server-sample

MCP Server for typecast-api, enabling seamless integration with MCP clients. This project provides a standardized way to interact with Typecast API through the Model Context Protocol.

## About

This project implements a Model [Context Protocol server](https://modelcontextprotocol.io/introduction) for Typecast API, allowing MCP clients to interact with the Typecast API in a standardized way.

## Feature Implementation Status

| Feature              | Status |
| -------------------- | ------ |
| **Voice Management** |        |
| Get Voices           | ✅     |
| Text to Speech       | ✅     |
| Play Audio           | ✅     |

## Setup

### Git Clone

```bash
git clone https://github.com/hyunseung/typecast-api-mcp-server-sample.git
cd typecast-api-mcp-server-sample
```

### Dependencies

This project requires Python 3.10 or higher and uses `uv` for package management.

#### Package Installation

```bash
# Create virtual environment and install packages
uv venv
uv pip install -e .
```

### Environment Variables

Set the following environment variables:

```bash
TYPECAST_API_HOST=https://api.typecast.ai
TYPECAST_API_KEY=<your-api-key>
TYPECAST_OUTPUT_DIR=<your-output-directory> # default: ~/Downloads/typecast_output
```

### Usage with Claude Desktop

You can add the following to your `claude_desktop_config.json`:

#### Basic Configuration:

```json
{
  "mcpServers": {
    "typecast-api-mcp-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/PATH/TO/YOUR/PROJECT",
        "run",
        "typecast-api-mcp-server"
      ],
      "env": {
        "TYPECAST_API_HOST": "https://api.typecast.ai",
        "TYPECAST_API_KEY": "YOUR_API_KEY",
        "TYPECAST_OUTPUT_DIR": "PATH/TO/YOUR/OUTPUT/DIR"
      }
    }
  }
}
```

Replace `/PATH/TO/YOUR/PROJECT` with the actual path where your project is located.

### Manual Execution

You can also run the server manually:

```bash
uv run python app/main.py
```

## Contributing

Contributions are always welcome! Feel free to submit a Pull Request.

## License

MIT License
orange-harvest-mcp 0.1.0
A simple MCP server for Harvest
Requires Python: >=3.6

# Harvest MCP Server

This MCP (Model Context Protocol) server provides integration with the Harvest time tracking and project management API. It allows Claude and other MCP-compatible AI assistants to interact with your Harvest account, helping you manage time entries, projects, clients, and more.

## Features

The server provides the following functionality:

### Users

- List users
- Get user details

### Time Entries
- List time entries with filtering options
- Create new time entries
- Start/stop timers
- Query time entry details

### Projects
- List projects with filtering options
- Retrieve detailed project information

### Clients
- List clients with filtering options
- Retrieve detailed client information

### Tasks
- List available tasks with filtering options

## Setup Instructions

### Prerequisites
- Python 3.10 or higher
- Harvest account with API access
- Harvest API key and Account ID

### Integrating with Claude Desktop

1. Create or edit your Claude Desktop configuration file:
   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`

2. Add the Harvest MCP server configuration:
   ```json
    {
        "mcpServers": {
            "harvest": {
                "command": "uv",
                "args": [
                  "run",
                  "--directory",
                  "change_directory",
                  "harvest-mcp-server.py"
                ],
                "env": {
                    "HARVEST_ACCOUNT_ID": "account_id",
                    "HARVEST_API_KEY": "api_key"
                }
            }
        }
    }
   ```

3. Restart Claude Desktop.

4. Verify the integration by looking for the hammer icon in Claude's interface.

## Example Queries

Once connected, you can ask Claude about your Harvest data with queries like:

- "Show me my time entries from last week"
- "List all my active projects"
- "Start a timer for project [project_id] and task [task_id]"
- "Show me all active clients"
- "List all available tasks"

## Customization

You can modify the server code to add more functionality or customize the existing tools to better suit your workflow. The server uses FastMCP, which makes it easy to add new tools by simply adding new functions with the `@mcp.tool()` decorator.

## Troubleshooting

- **API Errors**: Make sure your Harvest API key and Account ID are correct and have the necessary permissions.
- **Connection Issues**: Verify that your Claude Desktop configuration has the correct path to the server script.
- **Missing Dependencies**: Ensure you've installed all required packages in your Python environment.

## Security Notes

This server requires your Harvest API credentials to function. Make sure to:
- Keep your API key secure
- Do not share your claude_desktop_config.json file
- Consider using a dedicated API key with limited permissions for this integration
chromatinhd 0.4.3
High-definition modeling of (single-cell) chromatin + transcriptomics data
Requires Python: >=3.8
Keywords: bioinformatics, chromatin accessibility, transcriptomics

<p align="center">
  <a href="https://chromatinhd.org">
    <img src="https://raw.githubusercontent.com/DeplanckeLab/ChromatinHD/main/docs/source/static/logo.png" width="300" />
  </a>
  <a href="https://chromatinhd.org">
    <img src="https://raw.githubusercontent.com/DeplanckeLab/ChromatinHD/main/docs/source/static/comparison.gif" />
  </a>
</p>

ChromatinHD analyzes single-cell ATAC+RNA data using the raw fragments as input,
by automatically adapting the scale at which
relevant chromatin changes on a per-position, per-cell, and per-gene basis.
This enables identification of functional chromatin changes
regardless of whether they occur in a narrow or broad region.

As we show in [our paper](https://www.biorxiv.org/content/10.1101/2023.07.21.549899v1):
- Compared to the typical approach (peak calling + statistical analysis), ChromatinHD models are better able to capture functional chromatin changes. This is because there are extensive functional accessibility changes both outside and within peaks ([Figure 3](https://www.biorxiv.org/content/10.1101/2023.07.21.549899v1)).
- ChromatinHD models can capture long-range interactions by considering fragments co-occuring within the same cell ([Figure 4](https://www.biorxiv.org/content/10.1101/2023.07.21.549899v1)).
- ChromatinHD models can also capture changes in fragment size that are related to gene expression changes, likely driven by dense direct and indirect binding of transcription factors ([Figure 5](https://www.biorxiv.org/content/10.1101/2023.07.21.549899v1)).

[📜 Manuscript](https://www.biorxiv.org/content/10.1101/2023.07.21.549899v1)

[❔ Documentation](https://chromatinhd.org)

[▶️ Quick start](https://chromatinhd.org/quickstart/0_install)
lumigator-sdk 0.1.4a0
Lumigator SDK using the REST API
Requires Python: >=3.11

# Lumigator SDK

The SDK provides the communication and validation primitives needed to contact the Lumigator itself,
either locally or remotely.

You can install the lumigator SDK  via `pip` directly or via `uv` from the cloned repository:

```bash
pip install -e lumigator/sdk
```

or

```bash
uv pip install -e lumigator/sdk
```

Now that you have the SDK installed, you can use it to communicate with Lumigator. You can run the
[example notebook](/notebooks/walkthrough.ipynb) for a platform API walkthrough, or follow the
[quickstart guide](https://mozilla-ai.github.io/lumigator/get-started/quickstart.html) in the
documentation.

The SDK uses the `lumigator-schemas` package models, but with stricter validations, so properties not explicitly defined in the schemas will be handled as errors.

## Test instructions

The SDK includes both unit tests (requiring no additional containers) and integration tests (requiring a live Lumigator backend). By default only unit tests are run.

To run unit tests, please use:

```bash
uv run pytest
```

To run integration tests, please use:

```bash
pushd ../../../../ # go back to the project root
make start-lumigator-build # wait until all containers are up and running
popd
uv run pytest -o python_files="int_test_*.py" # wait until all tests have passed; update and repeat...
pushd ../../../../ # go back to the project root
make local-down # wait until all containers are removed
popd
```

The tests include a unit test suite and an integration test suite. There are make targets available at the root folder, as follows:

* `sdk-test`: runs `sdk-unit-test` and `sdk-int-test`
  * `sdk-unit-test`: runs tests in `backend/tests/unit/*/test_*.py` (any depth of subfolders)
  * `sdk-int-test`: runs tests in `backend/tests/int/*/test_*.py` (any depth of subfolders)

A live Lumigator backend is started for integration tests.