semvec/pypi-packages huggingface dataset:
pypeh 0.1.4
A modular project with a core library and multiple adapters
Requires Python: <4.0.0,>=3.10

# Installation

## Core Library
To install the core library for development, run:
```bash
uv sync
```

## Adapters
### Dataframe adapter
To install the dataframe adapter, run:
```bash
uv sync --extra dataframe_adapter
```

## Tests

```bash
make test-core
make test-dataframe
make test-rocrate
```
streamlit-pianoroll 0.7.5
Streamlit component that allows you to play piano
Requires Python: >=3.7

# Streamlit Pianoroll

Streamlit component that allows you to play MIDI.

## Installation instructions

```sh
pip install streamlit-pianoroll
```

## Usage instructions

```python
import streamlit as st

from pianoroll_streamlit import pianoroll

st.write("This is a pianoroll!")

pianoroll()
```

## Development instructions

* Initialize and run the component template frontend:
```
$ cd streamlit_pianoroll/frontend
$ npm install    # Install npm dependencies
$ npm run start  # Start the Webpack dev server
```
* From a separate terminal, run the template's Streamlit app:
```
$ cd template
$ . venv/bin/activate  # activate the venv you created earlier
$ pip install -e . # install template as editable package
$ streamlit run streamlit_pianoroll/example.py  # run the example
```
* If all goes well, you should see something like this:

<img width="666" alt="image" src="https://github.com/Nospoko/streamlit-pianoroll/assets/8056825/dcd09a8e-89b3-463b-854f-9fe3c18e8037">

### Code Style

This repository uses pre-commit hooks with forced python formatting ([black](https://github.com/psf/black),
[flake8](https://flake8.pycqa.org/en/latest/), and [isort](https://pycqa.github.io/isort/)):

```sh
pip install pre-commit
pre-commit install
```

Whenever you execute `git commit` the files altered / added within the commit will be checked and corrected.
`black` and `isort` can modify files locally - if that happens you have to `git add` them again.
You might also be prompted to introduce some fixes manually.

To run the hooks against all files without running `git commit`:

```sh
pre-commit run --all-files
```


### Publishing

[Tutorial](https://docs.streamlit.io/library/components/publish)


```
# Prepare JS
cd streamlit_pianoroll/frontend
npm run build
cd ../..

# Releasey PYPI
echo "Update version in setup.py, pls"
python setup.py sdist bdist_wheel
python -m twine upload --repository pypi dist/*
```
boring-semantic-layer 0.3.7
A boring semantic layer built with ibis
Requires Python: >=3.10

# Boring Semantic Layer (BSL)

The Boring Semantic Layer (BSL) is a lightweight semantic layer based on [Ibis](https://ibis-project.org/).

**Key Features:**
- **Lightweight**: `pip install boring-semantic-layer`
- **Ibis-powered**: Built on top of [Ibis](https://ibis-project.org/), supporting any database engine that Ibis integrates with (DuckDB, Snowflake, BigQuery, PostgreSQL, and more)
- **MCP-friendly**: Perfect for connecting LLMs to structured data sources

## Quick Start

```bash
pip install 'boring-semantic-layer[examples]'
```

**1. Define your ibis input table**

```python
import ibis

# Create a simple in-memory table
flights_tbl = ibis.memtable({
    "origin": ["JFK", "LAX", "JFK", "ORD", "LAX"],
    "carrier": ["AA", "UA", "AA", "UA", "AA"]
})
```

**2. Define a semantic table**

```python
from boring_semantic_layer import to_semantic_table
flights = (
    to_semantic_table(flights_tbl, name="flights")
    .with_dimensions(origin=lambda t: t.origin)
    .with_measures(flight_count=lambda t: t.count())
)
```

**3. Query it**

```python
result_df = flights.group_by("origin").aggregate("flight_count").execute()
```

---

## 📚 Documentation

**[→ View the full documentation](https://boringdata.github.io/boring-semantic-layer/)**

---

*This project is a joint effort by [xorq-labs](https://github.com/xorq-labs/xorq) and [boringdata](https://www.boringdata.io/).*

*We welcome feedback and contributions!*

---

*Freely inspired by the awesome [Malloy](https://github.com/malloydata/malloy) project. We loved the vision, just took the Python route.*
iraklis7-xgb 0.1.4
Exploration of medical data and classification using XGBoost regression
Requires Python: >3.10.0

# iraklis7_xgb

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

Exploration of medical data and classification using XGBoost regression

## Installation Instructions

pip install --upgrade pip\
pip install iraklis7_xgb\
pip install -r iraklis7_xgb/requirements.txt\
\
Also, you will need to set the IRAKLIS7_XGB_DATASET environment variable to the dataset name (default: heart.csv), which should be under iraklis7_xgb/data/raw.

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see www.mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         iraklis7_logrg and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── iraklis7_xgb       <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes iraklis7_logrg a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
copairs 0.5.4
Find pairs and compute metrics between them
Requires Python: <3.13,>=3.9
Keywords: pairwise, replication

 # copairs

`copairs` is a Python package for finding groups of profiles based on metadata and calculate mean Average Precision to assess intra- vs inter-group similarities.

## Getting started

### System requirements
copairs supports Python 3.9-3.12 and should work with all modern operating systems (tested with MacOS 13.5, Ubuntu 18.04, Windows 10).

### Dependencies
copairs depends on widely used Python packages:
* numpy
* pandas
* tqdm
* statsmodels
* [optional] plotly

### Installation

To install copairs and dependencies, run:
```bash
pip install copairs
```

To also install dependencies for running examples, run:
```bash
pip install copairs[demo]
```

### Testing

To run tests, run:
```bash
pip install -e .[test]
pytest
```

## Usage

We provide examples demonstrating how to use copairs for:
- [grouping profiles based on their metadata](./docs/examples/finding_pairs.ipynb)
- [calculating mAP to assess phenotypic activity of perturbations](./docs/examples/phenotypic_activity.ipynb)
- [calculating mAP to assess phenotypic consistency of perturbations](./docs/examples/phenotypic_consistency.ipynb)
- [estimating null size for mAP p-value calculation](./docs/examples/null_size.ipynb)

## Citation
If you find this work useful for your research, please cite our [paper](https://doi.org/10.1038/s41467-025-60306-2):

Kalinin, A.A., Arevalo, J., Serrano, E., Vulliard, L., Tsang, H., Bornholdt, M., Muñoz, A.F., Sivagurunathan, S., Rajwa, B., Carpenter, A.E., Way, G.P. and Singh, S., 2025. A versatile information retrieval framework for evaluating profile strength and similarity. _Nature Communications_ 16, 5181. doi:10.1038/s41467-025-60306-2

BibTeX:
```
@article{kalinin2025versatile,
  author       = {Kalinin, Alexandr A. and Arevalo, John and Serrano, Erik and Vulliard, Loan and Tsang, Hillary and Bornholdt, Michael and Muñoz, Alán F. and Sivagurunathan, Suganya and Rajwa, Bartek and Carpenter, Anne E. and Way, Gregory P. and Singh, Shantanu},
  title        = {A versatile information retrieval framework for evaluating profile strength and similarity},
  journal      = {Nature Communications},
  year         = {2025},
  volume       = {16},
  number       = {1},
  pages        = {5181},
  doi          = {10.1038/s41467-025-60306-2},
  url          = {https://doi.org/10.1038/s41467-025-60306-2},
  issn         = {2041-1723}
}
```
qubodock 0.2.5
QUBO GPU trainer
Requires Python: >=3.9

# qubodock

## Usage
```bash
qubodock-qubo \
  --device cuda \
  --learning-rate 5e-4 \
  --E-bond -1.5 \
  --E-vdw 15 \
  --num-step 20000 \
  --grid-path Grid \
  --h-base H_matrix \
  --j-path J_Matrix_0.7_1.3 \
  --out-xmat Xmat \
  --out-scor Scor

qubodock-dock \
  --select dock_table \
  --xmat Xmat \
  --grid Grid \
  --rec-root rec_pos \
  --lig-root lig_shift \
  --out-root ./lig_multi_pos \
  --vdw-table vdw_radius \
  --div 0.375 \
  --alpha-list 0.05,0.10 \
  --rec-filter-rad 13.0 \
  --clash-scale 0.50 \
  --use-gpu-triplets \
  --ij-batch 2048 \
  --enable-clash-check \
  --rec-chunk 4096

qubodock-rmsd \
  --score-root lig_multi_pos \
  --dock-table dock_table \
  --map-root lig_exp_pos \
  --out-root ./rmsd

qubodock-dpb2pdbqt \
  --dpb 1c5z.dpb \
  --template 1c5z_ligand.pdbqt \
  --out 1c5z_allposes.pdbqt

qubodock-gene_grid \
  --rad 7.0 \
  --div 0.375 \
  --out Grid

qubodock-gene_j_matrix \
  --grid-path Grid \
  --dis-path Dis \
  --out-dir J_Matrix \
  --div 0.375

qubodock-gene_h_matrix \
  --in-base map \
  --out-base Map \
  --grid-path Grid \
  --n 61 \
  --shift 30
mkdocs-decodiff-plugin 0.0.8
MkDocs plugin to decorate git diff lines
Requires Python: >=3.10

# mkdocs-decodiff-plugin

## Overview

This is an MkDocs plugin for decorating Git diff lines.

This program inserts HTML tags into Markdown files to decorate diff lines using `git diff` output.

![decoration-image](https://raw.githubusercontent.com/kkAyataka/mkdocs-decodiff-plugin/refs/heads/main/docs/_res/decoration-image.png)

## How to Use

### Install

```shell
pip install mkdocs-decodiff-plugin
```

### mkdocs.yml

```yml
plugins:
 - decodiff:
      base: main
      dir: docs
      change_list_file: docs/changes.md
```

* **base**:

  Reference for `git diff`. You can specify a hash, tag name, or branch name.

  ```
  git diff {base}
  ```
* **dir**:

  Target directory.

  ```
  git diff -- {dir}
  ```

* **change_list_file**:
  
  [Changes list file](#change_list_file)


## change_list_file

Collect change links in this file as a list.

```markdown
# Changes

<!-- decodiff: Written by decodiff from here -->
## [index.md](index.md)

* [new section](index.md#decodiff-anchor-1)

<!-- decodiff: end -->
```

The part between the `<!-- decodiff: -->` tags is generated by decodiff, but the rest can be modified.

```markdown
# You can change

You can change

<!-- decodiff: Written by decodiff from here -->

This section is overwritten by decodiff

<!-- decodiff: end -->

You can change
```

## NOT supported

* Changes in a code block
* Changes in a table
* Changes in HTML blocks
* Character unit changes

## Behavior

* Retrieve diff data using `git diff`
* Add an HTML tag to each diff line. For example:
    * `<span id="decodiff-hunk-1" class="decodiff">text</span>`
    * Preserve leading markup, such as headings (`#`) and bullet points (`*`)
* Create a diff list file containing a list of links

## LICENSE

[MIT License](../LICENSE)
jmeter-adva-mcp 0.1.0
Advanced JMeter and Log Analysis MCP Server
Requires Python: >=3.8

# JMeter Advanced MCP Server

A powerful Model Context Protocol (MCP) server for JMeter test execution and advanced log analysis.

## Features

- **JMeter Execution**: Run JMeter test plans (`.jmx`) directly from your agent.
- **Log Analysis**: Universal parser for JTL, CSV, Apache access logs, and application logs.
- **Auto-Correlation**: Identify and add dynamic value extractors to JMeter test plans.
- **Reporting**: Generate comprehensive Markdown reports with insights and statistics.
- **Dynatrace Integration**: Automatically add Dynatrace headers (LSN/TSN) to HTTP samplers.
- **Visualizations**: Generate response time distribution and endpoint performance graphs.

## Installation

```bash
pip install jmeter-adva-mcp
```

## Usage

### Run as an MCP Server

The server can be run as a stdio process:

```bash
jmetermcp
```

Or via python:

```bash
python -m jmetermcp
```

## Tools

- `run_test`: Run JMeter test plans.
- `analyze_results`: Analyze JTL results.
- `analyze_any_log_file`: Support for multiple log formats.
- `generate_analysis_report`: Create detailed Markdown reports.
- `correlate_jmeter_files`: Full correlation workflow.
- `auto_tag_dynatrace_headers`: Add Dynatrace headers to JMX files.
- `list_log_formats`: Check supported formats.

## License

MIT
web-poet 0.23.1
Zyte's Page Object pattern for web scraping
Requires Python: >=3.10

========
web-poet
========

.. image:: https://img.shields.io/pypi/v/web-poet.svg
   :target: https://pypi.python.org/pypi/web-poet
   :alt: PyPI Version

.. image:: https://img.shields.io/pypi/pyversions/web-poet.svg
   :target: https://pypi.python.org/pypi/web-poet
   :alt: Supported Python Versions

.. image:: https://github.com/scrapinghub/web-poet/actions/workflows/tests-ubuntu.yml/badge.svg
   :target: https://github.com/scrapinghub/web-poet/actions/workflows/tests-ubuntu.yml
   :alt: Tox Ubuntu

.. image:: https://github.com/scrapinghub/web-poet/actions/workflows/tests-windows.yml/badge.svg
   :target: https://github.com/scrapinghub/web-poet/actions/workflows/tests-windows.yml
   :alt: Tox Windows

.. image:: https://codecov.io/github/scrapinghub/web-poet/coverage.svg?branch=master
   :target: https://codecov.io/gh/scrapinghub/web-poet
   :alt: Coverage report

.. image:: https://readthedocs.org/projects/web-poet/badge/?version=stable
   :target: https://web-poet.readthedocs.io/en/stable/?badge=stable
   :alt: Documentation Status

.. intro starts

``web-poet`` is a Python 3.10+ implementation of the `page object pattern`_ for
web scraping. It enables writing portable, reusable web parsing code.

.. _page object pattern: https://martinfowler.com/bliki/PageObject.html

.. intro ends

See the documentation_.

.. _documentation: https://web-poet.readthedocs.io

Developing
==========

Setup your local Python environment via:

1. `pip install -r requirements-dev.txt`
2. `pre-commit install`

Now everytime you perform a `git commit`, these tools will run against the
staged files:

* `black`
* `isort`
* `flake8`

You can also directly invoke `pre-commit run --all-files` or `tox -e linters`
to run them without performing a commit.