semvec/pypi-packages huggingface dataset:
laris 0.9.0
LARIS enables accurate and efficient ligand and receptor interaction analysis in spatial transcriptomics
Requires Python: >=3.9
Keywords: bioinformatics, cell-communication, ligand-receptor, single-cell, spatial-transcriptomics

# LARIS: Ligand And Receptor Interaction in Spatial transcriptomics data


LARIS is a Python package for analyzing ligand-receptor interactions in spatial transcriptomics data. It identifies spatially-specific cell-cell communication patterns by integrating gene expression, spatial information, and cell type annotations.

### Features

- **Spatial LR interaction strength**: Calculate ligand-receptor interaction scores using spatial adjacency information
- **Spatial specificity**: Identify LR pairs with significant spatial variable patterns
- **Inference at cell type level**: Compute sender-receiver cell type interaction scores
- **Spatial neighborhoods**: Analyze interactions in the context of spatial cell type neighborhoods

### 📦 Installation

For the development version in GitHub, you could install via:
```bash
pip install git+https://github.com/genecell/LARIS.git
```

You could simply install LARIS via `pip` in your conda environment (future):
```bash
pip install laris
```

### Quick Start

```python
import laris as la
import scanpy as sc
import pandas as pd

# Load your spatial transcriptomics data
adata = sc.read_h5ad('spatial_data.h5ad')

# Define ligand-receptor pairs
lr_df = pd.DataFrame({
    'ligand': ['Tgfb1', 'Vegfa', 'Cxcl12'],
    'receptor': ['Tgfbr1', 'Kdr', 'Cxcr4']
})

# Step 1: Calculate LR integration scores
lr_adata = la.tl.prepareLRInteraction(
    adata, 
    lr_df,
    number_nearest_neighbors=15,
    use_rep_spatial='X_spatial'
)

# Step 2: Identify spatially-specific LR interactions and infer the LR interaction at cell type level
laris_results, celltype_results = la.tl.runLARIS(
    lr_adata,
    adata,
    n_nearest_neighbors=15,
    n_repeats=100,
    n_top_lr=1000,
    by_celltype=True,
    groupby='cell_type'
)

# View top spatially-specific LR pairs
print(laris_results.head(10))

# View top cell type-specific interactions
print(celltype_results.head(10))

# Filter for specific cell type pairs
endothelial_to_tumor = celltype_results[
    (celltype_results['sending_celltype'] == 'Endothelial') &
    (celltype_results['receiving_celltype'] == 'Tumor')
]
print(endothelial_to_tumor.head(10))
```
tap-shortcut 0.7.4
Singer tap for Shortcut, built with the Meltano SDK for Singer Taps.
Requires Python: >=3.10
Keywords: ELT, Shortcut, singer.io

<div align="center">

# tap-shortcut

<div>
  <a href="https://results.pre-commit.ci/latest/github/reservoir-data/tap-shortcut/main">
    <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/reservoir-data/tap-shortcut/main.svg"/>
  </a>
  <a href="https://github.com/reservoir-data/tap-shortcut/blob/main/LICENSE">
    <img alt="License" src="https://img.shields.io/github/license/reservoir-data/tap-shortcut"/>
  </a>
</div>

Singer tap for Shortcut. Built with the [Meltano Tap SDK](https://sdk.meltano.com) for Singer Taps.

</div>

## Capabilities

* `catalog`
* `state`
* `discover`
* `about`
* `stream-maps`

## Settings

| Setting | Required | Default | Description    |
|:--------|:--------:|:-------:|:---------------|
| token   | True     | None    | Shortcut Token |

A full list of supported settings and capabilities is available by running: `tap-shortcut --about`

### Source Authentication and Authorization

See https://developer.shortcut.com/api/rest/v3#Authentication.

## Usage

You can easily run `tap-shortcut` by itself or in a pipeline using [Meltano](https://meltano.com/).

### Executing the Tap Directly

```bash
tap-shortcut --version
tap-shortcut --help
tap-shortcut --config CONFIG --discover > ./catalog.json
```

## Developer Resources

### Initialize your Development Environment

Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already.

### Create and Run Tests

Run integration tests:

```bash
uv run pytest
```

You can also test the `tap-shortcut` CLI interface directly:

```bash
uv run tap-shortcut --help
```

### Testing with [Meltano](https://www.meltano.com)

_**Note:** This tap will work in any Singer environment and does not require Meltano.
Examples here are for convenience and to streamline end-to-end orchestration scenarios._

Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

1. Install all plugins

   ```bash
   meltano install
   ```

1. Check that the extractor is working properly

   ```bash
   meltano invoke tap-shortcut --version
   ```

1. Execute an ELT pipeline

   ```bash
   meltano run tap-shortcut target-jsonl
   ```

### SDK Dev Guide

See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
develop your own taps and targets.
datasette-enrichments-llm 0.1a3
Enrich data by prompting LLMs
Requires Python: >=3.10

# datasette-enrichments-llm

[![PyPI](https://img.shields.io/pypi/v/datasette-enrichments-llm.svg)](https://pypi.org/project/datasette-enrichments-llm/)
[![Changelog](https://img.shields.io/github/v/release/datasette/datasette-enrichments-llm?include_prereleases&label=changelog)](https://github.com/datasette/datasette-enrichments-llm/releases)
[![Tests](https://github.com/datasette/datasette-enrichments-llm/actions/workflows/test.yml/badge.svg)](https://github.com/datasette/datasette-enrichments-llm/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/datasette/datasette-enrichments-llm/blob/main/LICENSE)

Enrich data by prompting LLMs

This is an **early alpha**.

## Installation

Install this plugin in the same environment as Datasette.
```bash
datasette install datasette-enrichments-llm
```
## Usage

The plugin will enable enrichments to be run against any [LLM](https://llm.datasette.io/) model that has an LLM plugin providing [asynchronous support](https://llm.datasette.io/en/stable/plugins/advanced-model-plugins.html#async-models) for that model.

Multi-modal models are supported via the `media_url` parameter.

API keys currently use the default LLM mechanism, probably best set using environment variables.

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd datasette-enrichments-llm
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
pip install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
wlkngkr 0.1.1
Modular environment probe framework
Requires Python: >=3.10
Keywords: cli, diagnostics, environment, probe, pydantic


# wlkngkr

`wlkngkr` is a modular, extensible environment probing framework. Each probe is a focused Python class, the runner orchestrates them, and the CLI produces structured `pydantic` reports that you can feed into logging, diagnostics, or compliance tooling.

## Features

- Batteries-included probes for system and user context.
- Central registry + runner that selects probes by name or tag.
- Typed results (`EnvReport`, `ProbeResult`) built with `pydantic`.
- Typer-powered CLI that doubles as a Python API (`ProbeRunner`).
- Shipping via Apache 2.0 so it can live inside automation pipelines.

## Installation

Stable releases will be published to PyPI.

```bash
pip install wlkngkr
# or, with uv (recommended for contributors)
uv tool install wlkngkr
```

If you want to work from the repo:

```bash
git clone https://github.com/cprima-forge/wlkngkr.git
cd wlkngkr
uv sync --dev
```

## Usage

List available probes and run everything (default JSON output):

```bash
uv run wlkngkr --list
uv run wlkngkr --probe system --probe user
```

Prefer human-friendly status lines? Use the built-in `text` formatter:

```bash
uv run wlkngkr --format text
[system] status=success
[user]   status=success
```

Python API usage is equally straightforward:

```python
from wlkngkr.runner import ProbeRunner
from wlkngkr.config import RunnerConfig

runner = ProbeRunner()
report = runner.run(RunnerConfig(tags=["core"]))
print(report.model_dump())
```

## Development

```bash
uv sync --all-extras --dev
uv run pytest
```

Useful scripts:

- `uv run wlkngkr run --probe system` – run a single probe
- `uv run wlkngkr --list` – check registry state

## Releasing

1. Update `CHANGELOG.md` and bump `pyproject.toml`'s version.
2. Commit the release (`git commit -am "chore: release v0.x.y"`).
3. Tag it (`git tag v0.x.y && git push origin v0.x.y`).
4. GitHub Actions (`.github/workflows/release.yml`) will run tests, build the distribution via `uv build`, and publish to PyPI. When a `PYPI_API_TOKEN` secret is present, the workflow uploads with `twine>=6.1.0`; otherwise it falls back to PyPI Trusted Publishing (OIDC).

## License

Apache License 2.0 – see [`LICENSE`](./LICENSE).

## Maintainer

Christian Prior-Mamulyan ([@cprima](https://github.com/cprima)) — cprior@gmail.com
memobj 0.17.0
A library for defining objects in memory
Requires Python: >=3.11

# memobj

A Python library for defining and reading structured objects directly from another process's memory.

## Installation

- Using pip:
  - pip install memobj
- Using uv:
  - uv add memobj  

## Quickstart

```python
import os
from memobj import WindowsProcess, MemoryObject
from memobj.property import Signed4

class PythonIntObject(MemoryObject):
    # note: this offset might be different in future python versions
    value: int = Signed4(24)

process = WindowsProcess.from_id(os.getpid())

# id(x) gives the address of the object in cpython
my_int = PythonIntObject(address=id(1), process=process)

# prints 1
print(my_int.value)
```

See tests for more examples (pointer properties, process/module utilities, etc.).

## Development setup

This project uses uv as the build backend and package manager.

- Sync dependencies (including the tests group):
  - uv sync --all-groups
- Run tests:
  - uv run pytest
- Format code:
  - isort . && black .

Optional: A Nix flake provides a dev shell with Python 3.11, just, black, isort, and more:

- nix develop

## Support

discord: <https://discord.gg/wcftyYm6qe>