semvec/pypi-packages huggingface dataset:
tropea-clustering 2.1.2
Code for unsupervised clustering of time-correlated data.
Requires Python: >=3.9

# tropea_clustering
tropea-clustering (the newest version of onion-clustering) is a Python package for single-point time-series clustering. 

Author: Matteo Becchi

## Developement history
This version of onion clustering is meant to be used as an external library, and complies with the scikit-learn format. If you are looking for the standalone onion clustering version, you can find it at https://github.com/matteobecchi/timeseries_analysis. However, be aware that the standalone version has been last updated on September, 2024 and is no longer supported or mantained. We reccomand using this version. 

## Installation
To get `tropea-clustering`, you can install it with pip

``pip install tropea-clustering``

The `examples/` folder contains examples of usage. 

## Documentation
https://onion-clustering.readthedocs.io/en/latest/index.html. 

## Overview
Onion Clustering is an algorithm for single-point clustering of time-series data. It performs the clustering analyses at a specific time-resolution $\Delta t$, which is the minimum lifetime required for a cluster to be characterized as a stable environment. The clustering proceeds in an iterative way. At each iteration, the maximum of the cumulative distribution of data points is identified as a Gaussian state (meaning, a state characterized by the mean value and the variance of the signal inside it). Then, all the signal sequences close to the Gaussian mean and of length at least $\Delta t$ are classified as belonging to that state. These signals are then removed from the analysis, in order to enhance the resolution on the still unclassified signals at the next iteration. At the end of the process each frame is thus either classified in one of the identified states, or labelled as "unclassified" at that specific time resolution. 

Performing this analysis at different values of the time resolution $\Delta t$ allows to automatically identify the optimal choice of $\Delta t$ that maximizes the number of environments correctly separated, and minimizes the fraction of unclassified points. Complete details can be found at https://doi.org/10.1073/pnas.2403771121.

## Dependencies
- [numpy](https://numpy.org)
- [scipy](https://docs.scipy.org/doc/scipy/index.html)
- [scikit-learn](https://scikit-learn.org/stable/)

For plotting the results, you will need also 
- [matplotlib](https://matplotlib.org)
- [plotly](https://plotly.com/graphing-libraries/) (optional)
- [kaleido](https://pypi.org/project/kaleido/) (optional)

## How to cite us
If you use tropea-clustering (or onion-clustering) in your work, please cite https://doi.org/10.1073/pnas.2403771121. 

## Aknowledgements
We developed this code when working in the Pavan group, https://www.gmpavanlab.com/. Thanks to Andrew Tarzia for all the help with the code formatting and documentation, and to Domiziano Doria, Chiara Lionello and Simone Martino for the beta-testing. 

The work was funded by the European Union and ERC under projects DYNAPOL and the NextGenerationEU project.
rpbp 4.0.1
Rp-Bp: Ribosome Profiling with Bayesian Predictions
Requires Python: <3.14,>=3.11
Keywords: Bioinformatics, Ribo-seq/Ribosome profiling quality control, Open reading frame (ORF) discovery, Translation prediction

# Ribosome profiling with Bayesian predictions (Rp-Bp)

Ribosome profiling (Ribo-seq) is an RNA-sequencing-based readout of RNA translation. Isolation and deep-sequencing of ribosome-protected RNA fragments (ribosome footprints) provides a genome-wide snapshot of the translatome at sub-codon resolution. **Rp-Bp** is an unsupervised Bayesian approach to predict translated open reading frames (ORFs) from ribosome profiles. **Rp-Bp** can be used for ORF discovery, or simply to estimate periodicity in a set of Ribo-seq samples. When used for ORF discovery, **Rp-Bp** automatically classifies ORFs into different biotypes or categories, relative to their host transcript.

**Rp-Bp** comes with two _interactive dashboards_ or _web applications_, one for read and periodicity quality control, the other to facilitate Ribo-seq ORFs discovery.

<p align="center">
  <a href="https://rp-bp.readthedocs.io/en/latest/"><img alt="Rp-Bp" src="https://github.com/dieterich-lab/rp-bp/raw/master/docs/source/_static/logo-rpbp-dark.png"></a>
</p>

<p align="center">
<a href="http://bioconda.github.io/recipes/rpbp/README.html"><img alt="Install with bioconda" src="https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat"></a>
<a href="https://pypi.org/project/rpbp/"><img alt="PyPI" src="https://img.shields.io/pypi/v/rpbp"></a>
<a href="https://github.com/dieterich-lab/rp-bp/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/dieterich-lab/rp-bp/actions/workflows/ci.yml/badge.svg"></a>
<a href="https://rp-bp.readthedocs.io/en/latest/?badge=latest"><img alt="Docs" src="https://readthedocs.org/projects/rp-bp/badge/?version=latest"></a>
</p>

---

## Documentation

Consult the [user guide](http://rp-bp.readthedocs.io/en/latest/) for instructions on how to install the package, or to use Docker/Singularity containers with the package pre-installed. Detailed usage instructions and tutorials are available.

## How to report issues

For bugs, issues, or feature requests, use the [bug tracker](https://github.com/dieterich-lab/rp-bp/issues). Follow the instructions and guidelines given in the templates.

## How to cite

Brandon Malone, Ilian Atanassov, Florian Aeschimann, Xinping Li, Helge Großhans, Christoph Dieterich. [Bayesian prediction of RNA translation from ribosome profiling](https://doi.org/10.1093/nar/gkw1350), _Nucleic Acids Research_, Volume 45, Issue 6, 7 April 2017, Pages 2960-2972.

## License

The MIT License (MIT). Copyright (c) 2016 dieterich-lab.
glue-vispy-viewers 1.3.0
Vispy-based viewers for Glue
Requires Python: >=3.8

Glue plugin for 3D viewers using VisPy
======================================

Requirements
------------

Note that this plugin requires `Glue <http://glueviz.org/>`__ and
`PyOpenGL <http://pyopengl.sourceforge.net/>`__ to be installed - see
`this page <http://glueviz.org/en/latest/installation.html>`__ for
instructions on installing Glue. PyOpenGL should get installed
automatically when you install the plugin (see below).

While this plugin uses VisPy, for now we bundle our own version of VisPy
since we rely on some recently added features, so you do not need to
install VisPy separately.

Installing
----------

If you use conda, you can install this plugin with::

    conda install -c conda-forge glue-vispy-viewers

or using pip::

    pip install glue-vispy-viewers

This will auto-register the plugin with Glue. Now simply start up Glue,
open a data cube, drag it onto the main canvas, then select one of the
3D viewer choices.

Testing
-------

To run the tests, do::

    pytest glue_vispy_viewers

at the root of the repository. This requires the
`pytest <http://pytest.org>`__ module to be installed.
exec-dir-mcp 1.0.2
MCP服务器，支持在指定目录中安全执行命令
Requires Python: >=3.10

# Exec Dir MCP

一个基于 Model Context Protocol (MCP) 的命令执行服务器，支持在指定目录中安全地执行命令。

## 功能特性

- 🎯 **安全执行**：支持配置允许的目录列表，防止在未授权目录执行命令
- 📁 **灵活配置**：可设置默认工作目录，支持在任意允许的目录执行命令
- ⏱️ **超时控制**：支持自定义命令执行超时时间
- 🔄 **异步执行**：基于 asyncio 的异步命令执行，性能优异
- 📊 **详细日志**：完整的执行日志记录，方便调试和监控
- 🛡️ **目录验证**：自动验证目录存在性和权限

## 安装

### 系统要求

- Python >= 3.13
- uv (推荐) 或 pip

### 使用 uv 安装

```bash
# 克隆仓库
git clone https://github.com/yunhai-dev/exec-dir-mcp.git
cd exec-dir-mcp

# 安装依赖
uv sync

# 开发模式安装
uv pip install -e .
```

### 使用 pip 安装

```bash
pip install -e .
```

## 使用方法

### 作为 MCP 服务器运行

#### 基本用法

```bash
# 使用当前目录作为默认目录，允许所有目录
python -m exec_dir_mcp.main

# 指定默认目录
python -m exec_dir_mcp.main --dir /home/user/projects

# 指定默认目录和允许的目录列表
python -m exec_dir_mcp.main --dir /home/user/projects --allowed /home/user/projects --allowed /tmp
```

#### 命令行参数

- `--dir`：默认工作目录（默认：当前目录）
- `--allowed`：允许执行命令的目录（可多次指定，不指定则允许所有目录）

#### 示例

```bash
# 在项目目录中运行，允许访问项目目录和临时目录
python -m exec_dir_mcp.main \
  --dir /home/user/my-project \
  --allowed /home/user/my-project \
  --allowed /tmp

# 安全模式：只允许特定目录
python -m exec_dir_mcp.main \
  --dir /safe/workspace \
  --allowed /safe/workspace/project1 \
  --allowed /safe/workspace/project2
```

### 在代码中使用

```python
import asyncio
from exec_dir_mcp.main import MCPServer

async def main():
    # 创建服务器实例
    server = MCPServer(
        default_dir="/home/user/projects",
        allowed_dirs=["/home/user/projects", "/tmp"]
    )

    # 运行服务器
    await server.run()

asyncio.run(main())
```

## MCP 工具

### execute_command

在指定目录中执行命令。

#### 参数

- `command` (string, 必需)：要执行的 shell 命令
- `working_dir` (string, 可选)：工作目录（默认使用配置的默认目录）
- `timeout` (integer, 可选)：超时时间，单位秒（默认：30）

#### 返回值

```json
{
  "success": true,
  "stdout": "命令标准输出",
  "stderr": "命令标准错误输出",
  "returncode": 0,
  "working_dir": "/执行目录",
  "command": "执行的命令"
}
```

#### 错误响应

```json
{
  "success": false,
  "error": "错误描述"
}
```

#### 使用示例

```python
# 通过 MCP 客户端调用
result = await client.call_tool("execute_command", {
    "command": "ls -la",
    "working_dir": "/home/user/projects",
    "timeout": 10
})
```

## 项目结构

```
exec-dir-mcp/
├── README.md                 # 项目文档
├── pyproject.toml           # 项目配置
├── .gitignore              # Git 忽略文件
├── .python-version         # Python 版本
├── src/
│   └── exec_dir_mcp/
│       ├── __init__.py      # 包初始化
│       ├── main.py          # 主程序逻辑
│       └── py.typed         # 类型提示标记
```

## 协议支持

- **MCP 版本**：2024-11-05
- **JSON-RPC**：2.0
- **传输协议**：标准输入/输出

## 安全说明

1. **目录限制**：强烈建议在生产环境中配置 `--allowed` 参数限制可访问的目录
2. **命令执行**：服务器会执行传入的任意 shell 命令，请确保客户端输入的安全性
3. **超时保护**：默认 30 秒超时，可通过 `timeout` 参数调整
4. **路径验证**：自动验证目录存在性和权限

## 开发

### 运行测试

```bash
uv run pytest
```

### 代码格式化

```bash
uv run ruff format .
uv run ruff check .
```

## 许可证

MIT License

## 作者

YunHai <yunhai@bybxbwg.fun>

## 贡献

欢迎提交 Issue 和 Pull Request！

## 更新日志

### v0.1.0

- 初始版本
- 支持基本的命令执行功能
- 支持目录权限控制
- 支持超时配置
simpleflow 0.34.2
Python library for dataflow programming with Amazon SWF
Requires Python: >=3.7
Keywords: amazon swf, simple workflow, simpleflow

Simpleflow
==========

![PyPI - Version](https://img.shields.io/pypi/v/simpleflow)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/botify-labs/simpleflow/ci.yml)


Simpleflow is a Python library that provides abstractions to write programs in
the [distributed dataflow paradigm](https://en.wikipedia.org/wiki/Distributed_data_flow).
It coordinates the execution of distributed tasks with [Amazon SWF](https://aws.amazon.com/swf/).

It relies on *futures* to describe the dependencies between tasks. A `Future` object
models the asynchronous execution of a computation that may end.  It tries to mimic
the interface of the Python [concurrent.futures](http://docs.python.org/3/library/concurrent.futures) library.


Features
--------

- Provides a `Future` abstraction to define dependencies between tasks.
- Define asynchronous tasks from callables.
- Handle workflows with Amazon SWF.
- Implement replay behavior like the Amazon Flow framework.
- Handle retry of tasks that failed.
- Automatically register decorated tasks.
- Encodes/decodes large fields to S3 objects transparently (aka "jumbo fields").
- Handle the completion of a decision with more than 100 tasks.
- Provides a local executor to check a workflow without Amazon SWF (see
  `simpleflow --local` command).
- Provides decider and activity worker process for execution with Amazon SWF.
- Ships with the `simpleflow` command. `simpleflow --help` for more information
  about the commands it supports.

You can read more in the **Features** section of the documentation.


Overview
--------

Please read and even run the `demo` script to have a quick glance of
`simpleflow` commands. To run the `demo`  you will need to start decider
and activity worker processes.

Start a decider with:

    $ PYTHONPATH=$PWD simpleflow decider.start --domain TestDomain --task-list test examples.basic.BasicWorkflow

Start an activity worker with:

    $ simpleflow worker.start --domain TestDomain --task-list quickstart

Then execute `./extras/demo`.


More information
----------------

Read the main documentation at https://botify-labs.github.io/simpleflow/.
agentcache 0.3.0
Official Python client for AgentCache.ai - Reduce LLM costs by 90%
Requires Python: >=3.7

# AgentCache Python Client

Official Python client for [AgentCache.ai](https://agentcache.ai) - The Global Edge Cache for LLMs.

## Installation

```bash
pip install agentcache
```

## Usage

### Standard Completion

```python
import agentcache

# Drop-in replacement for OpenAI call logic
response = agentcache.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello world"}],
    provider="openai"  # optional, defaults to openai
)

if response and response.get('hit'):
    print("Cache HIT:", response['response'])
else:
    print("Cache MISS - Call your LLM here")
```

### Streaming

AgentCache supports streaming responses, making it compatible with chat UIs that expect Server-Sent Events (SSE).

```python
stream = agentcache.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

if stream:
    print("Cache HIT (Streaming):")
    for chunk in stream:
        content = chunk['choices'][0]['delta'].get('content', '')
        print(content, end="", flush=True)
```

### Reasoning Cache (NEW in v0.3.0)

Cache reasoning traces for o1, Kimi, and DeepSeek models:

```python
response = agentcache.completion(
    model="o1-preview",
    messages=[{"role": "user", "content": "Analyze this contract..."}],
    strategy="reasoning_cache"
)

if response and response.get('cached'):
    print("Reasoning trace retrieved from cache")
```

### Multimodal Cache (NEW in v0.3.0)

Cache 3D meshes, images, and audio for generative models:

```python
response = agentcache.completion(
    model="sam-3d-body",
    messages=[{
        "role": "user",
        "content": "Generate 3D model",
        "file_path": "input.jpg"
    }],
    strategy="multimodal"
)

if response and response.get('cached'):
    asset_data = response['asset']
    print(f"Retrieved cached 3D asset: {len(asset_data['vertices'])} vertices")
```

## Environment Variables

Set `AGENTCACHE_API_KEY` in your environment, or pass `api_key` to the constructor.

```python
from agentcache import AgentCache

client = AgentCache(api_key="ac_live_...")
```