asbm 0.1.4.dev3__cp313-cp313-win_amd64.whl

asbm/__init__.py

@@ -0,0 +1,18 @@
+"""
+Copyright (c) 2025 Max Jerdee. All rights reserved.
+
+asbm: Finding group structure in networks
+"""
+
+from __future__ import annotations
+
+from ._version import version as __version__
+
+__all__ = [
+    "__version__",
+    "Config",
+    "Result",
+    "fit",
+]
+
+from .core import Config, Result, fit

asbm/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.4.dev3'
+__version_tuple__ = version_tuple = (0, 1, 4, 'dev3')
+
+__commit_id__ = commit_id = 'gd2cbac3fd'

asbm/core.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+import networkx as nx
+
+try:
+    from ._asbm import FitResult as _NativeFitResult
+    from ._asbm import fit_backend
+except ImportError as e:  # pragma: no cover
+    _NativeFitResult = None  # type: ignore[assignment]
+    fit_backend = None  # type: ignore[assignment]
+    _BACKEND_IMPORT_ERROR = e
+else:
+    _BACKEND_IMPORT_ERROR = None
+
+
+ModelName = Literal[
+    "asbm", "general_canonical", "general_unified",
+    "simple_asbm", "simple_ASBM",
+    "general_asbm", "general_ASBM",
+    "hybrid_ASBM",
+    "planted_partition",
+    "traditional_SBM", "traditional_DCSBM", "traditional_GDCSBM",
+    "microcanonical_SBM", "microcanonical_DCSBM",
+]
+
+_ALLOWED_MODELS: frozenset[str] = frozenset({
+    "asbm", "general_canonical", "general_unified",
+    "simple_asbm", "simple_ASBM",
+    "general_asbm", "general_ASBM",
+    "hybrid_ASBM",
+    "planted_partition",
+    "traditional_SBM", "traditional_DCSBM", "traditional_GDCSBM",
+    "microcanonical_SBM", "microcanonical_DCSBM",
+})
+
+@dataclass(frozen=True)
+class Config:
+    model: ModelName = "asbm"
+    degree_correction: bool = True
+
+    def __post_init__(self) -> None:
+        if self.model not in _ALLOWED_MODELS:
+            raise ValueError(
+                "model must be one of: " + ", ".join(sorted(_ALLOWED_MODELS))
+            )
+
+
+class Result:
+    def __init__(self, native_result: _NativeFitResult, node_order: tuple[object, ...]) -> None:
+        self._native_result = native_result
+        self._node_order = node_order
+
+    @property
+    def mdl_value(self) -> float:
+        return float(self._native_result.mdl_value)
+
+    @property
+    def mdl_partition(self) -> np.ndarray:
+        return np.asarray(self._native_result.mdl_partition, dtype=int)
+
+    @property
+    def summary(self) -> dict:
+        return dict(self._native_result.summary)
+
+    def samples_df(self):
+        return self._native_result.samples_df()
+
+    def consensus_partition(self) -> np.ndarray:
+        return np.asarray(self._native_result.consensus_partition(), dtype=int)
+
+    def coincidence_matrix(self) -> np.ndarray:
+        return np.asarray(self._native_result.coincidence_matrix(), dtype=float)
+
+    def log_posterior_predictive(self, G_test: nx.Graph, f: float | None = None) -> float:
+        index_of = {node: i for i, node in enumerate(self._node_order)}
+        test_nodes = set(G_test.nodes())
+        train_nodes = set(self._node_order)
+        if test_nodes != train_nodes:
+            missing = sorted(train_nodes - test_nodes)
+            extra = sorted(test_nodes - train_nodes)
+            raise ValueError(f"Test graph node set must match the training graph. Missing={missing}, extra={extra}")
+
+        test_edges = [
+            (
+                index_of[u],
+                index_of[v],
+                float(data.get("weight", 1.0)),
+            )
+            for u, v, data in G_test.edges(data=True)
+        ]
+        return float(self._native_result.log_posterior_predictive(test_edges, f))
+
+
+def _require_backend() -> None:
+    if fit_backend is None:
+        raise ImportError(
+            "Native backend unavailable. Build the extension module first."
+        ) from _BACKEND_IMPORT_ERROR
+
+
+def fit(
+    config: Config,
+    G: nx.Graph,
+    *,
+    sweeps: int = 100,
+    burn_sweeps: int = 100,
+    num_chains: int = 2,
+    samples_per_chain: int = 1,
+    num_samples: int | None = None,
+    thinning: int = 1,
+    seed: int = 0,
+    show_progress: bool = False,
+) -> Result:
+    _require_backend()
+
+    if not isinstance(config, Config):
+        raise TypeError("config must be an instance of Config")
+    if not isinstance(G, nx.Graph):
+        raise TypeError("G must be a networkx.Graph")
+
+    if num_samples is not None:
+        if num_samples <= 0:
+            raise ValueError("num_samples must be positive")
+        num_chains = 1
+        samples_per_chain = int(num_samples)
+
+    if sweeps <= 0:
+        raise ValueError("sweeps must be positive")
+    if burn_sweeps < 0:
+        raise ValueError("burn_sweeps must be non-negative")
+    if num_chains <= 0:
+        raise ValueError("num_chains must be positive")
+    if samples_per_chain <= 0:
+        raise ValueError("samples_per_chain must be positive")
+    if thinning <= 0:
+        raise ValueError("thinning must be positive")
+
+    nodes = sorted(G.nodes())
+    index_of = {node: i for i, node in enumerate(nodes)}
+    edges = [
+        (
+            index_of[u],
+            index_of[v],
+            float(data.get("weight", 1.0)),
+        )
+        for u, v, data in G.edges(data=True)
+    ]
+
+    native_result = fit_backend(
+        num_nodes=len(nodes),
+        edges=edges,
+        model=config.model,
+        degree_correction=config.degree_correction,
+        sweeps=sweeps,
+        burn_sweeps=burn_sweeps,
+        num_chains=num_chains,
+        samples_per_chain=samples_per_chain,
+        thinning=thinning,
+        seed=seed,
+        show_progress=show_progress,
+    )
+    return Result(native_result, tuple(nodes))

asbm/input_output.py

@@ -0,0 +1,316 @@
+# Handling input and output of data
+
+import networkx as nx
+import pandas as pd
+from typing import Optional, Iterable
+import warnings
+
+# Sentinel for unset parameters
+_UNSET = object()
+
+
+def _canonical_model_name(model_name: str) -> str:
+    """
+    Validate that `model_name` is one of the canonical model identifiers.
+
+    This function only accepts canonical names (case-insensitive) and returns
+    the canonical-cased string. Using legacy aliases is not permitted; callers
+    should pass canonical model names such as "simple_ASBM" or
+    "general_ASBM".
+    """
+    if not isinstance(model_name, str):
+        raise TypeError("model_name must be a string containing a canonical model name")
+    name = model_name.strip()
+    canonical = {
+        "general_canonical": "general_canonical",
+        "general_unified": "general_unified",
+        "general_ASBM": "general_ASBM",
+        "simple_ASBM": "simple_ASBM",
+        "hybrid_ASBM": "hybrid_ASBM",
+        "traditional_SBM": "traditional_SBM",
+        "traditional_DCSBM": "traditional_DCSBM",
+        "traditional_GDCSBM": "traditional_GDCSBM",
+        "microcanonical_SBM": "microcanonical_SBM",
+        "microcanonical_DCSBM": "microcanonical_DCSBM",
+        "planted_partition": "planted_partition",
+    }
+    lower_map = {k.lower(): v for k, v in canonical.items()}
+    if name.lower() in lower_map:
+        return lower_map[name.lower()]
+    raise ValueError(
+        "model_name must be one of the canonical names: " + ", ".join(sorted(canonical.values())) +
+        f". Got '{model_name}'."
+    )
+
+
+# Check that the arguments passed to the function are valid, if not raise an error
+def _check_input_validity(
+    G: nx.Graph,
+    node_groups: Optional[pd.DataFrame] = None,
+    *,
+    model_name: str = "general_canonical",
+    assortative: bool = _UNSET,
+    mixing_variation: str = _UNSET,
+    variation_in: Optional[float] = _UNSET,
+    variation_out: Optional[float] = _UNSET,
+    degree_correction: Optional[float] = _UNSET,
+    num_groups: Optional[int] = _UNSET,
+    initial_partition: Optional[Iterable[int]] = None,
+    seed: Optional[int] = None,
+    num_samples: int = 1000,
+    beta: float = 1.0,
+    num_tempering_chains: int = 1,
+    no_cache: bool = False,
+    timeout: float = 60.0,
+    verbose: bool = False,
+) -> None:
+    """Validate public API inputs and raise informative errors for invalid values.
+
+    This function checks types, ranges and basic consistency for the parameters
+    documented in the public API. It intentionally performs lightweight checks
+    only (no heavy computation or graph processing).
+    """
+
+    # Graph checks
+    if not isinstance(G, nx.Graph):
+        raise TypeError("G must be a NetworkX Graph object.")
+    
+    # model_name
+    model_name = _canonical_model_name(model_name)
+
+    # Fix the unset parameters to their defaults (to pass the type checks below)
+    if assortative is _UNSET:
+        assortative = True
+    if mixing_variation is _UNSET:
+        mixing_variation = "general"
+    if variation_in is _UNSET:
+        variation_in = None
+    if variation_out is _UNSET:
+        variation_out = None
+    if degree_correction is _UNSET:
+        degree_correction = None
+    # mean_degree_scaling has been fixed to 0.0 and is no longer configurable
+    if num_groups is _UNSET:
+        num_groups = None
+
+    # assortative
+    if not isinstance(assortative, bool):
+        raise TypeError("assortative must be a boolean.")
+
+    # mixing_variation
+    valid_mixing = ["simple", "none", "internal", "external", "general"]
+    if mixing_variation not in valid_mixing:
+        raise ValueError(f"mixing_variation must be one of {valid_mixing}")
+
+    # variation_in/out: None or 0 <= x <= 1
+    for name, val in (("variation_in", variation_in), ("variation_out", variation_out)):
+        if val is not None:
+            if not isinstance(val, (int, float)):
+                raise TypeError(f"{name} must be a float in [0, 1] or None.")
+            if not (0.0 <= float(val) <= 1.0):
+                raise ValueError(f"{name} must be between 0 and 1 (inclusive). Got {val}.")
+
+    # degree_correction: None or 0 <= x <= 1
+    if degree_correction is not None:
+        if not isinstance(degree_correction, (int, float)):
+            raise TypeError("degree_correction must be a float in [0, 1] or None.")
+        if not (0.0 <= float(degree_correction) <= 1.0):
+            raise ValueError("degree_correction must be between 0 and 1 (inclusive).")
+
+    # mean_degree_scaling removed from user-facing API
+
+    # num_groups must be positive integer if provided and not greater than number of nodes
+    if num_groups is not None:
+        if not isinstance(num_groups, int) or num_groups <= 0:
+            raise ValueError("num_groups must be a positive integer or None.")
+        if G is not None and num_groups > G.number_of_nodes():
+            raise ValueError("num_groups cannot be greater than the number of nodes in G.")
+
+    # initial_partition: if provided, must be iterable of ints of length equal to number of nodes
+    if initial_partition is not None:
+        try:
+            ip_list = list(initial_partition)
+        except Exception:
+            raise TypeError("initial_partition must be an iterable of integers or None.")
+        if G is not None and len(ip_list) != G.number_of_nodes():
+            raise ValueError("initial_partition length must match number of nodes in G.")
+        for v in ip_list:
+            if not isinstance(v, int) or v < 0:
+                raise ValueError("initial_partition must contain non-negative integer labels.")
+        if num_groups is not None:
+            if max(ip_list) >= num_groups:
+                raise ValueError("initial_partition contains labels >= num_groups.")
+        # Make sure that each group has at least one member
+        unique_groups = set(ip_list)
+        if len(unique_groups) < max(ip_list) + 1:
+            raise ValueError("initial_partition does not contain members for every group.")
+        if num_groups is not None and len(unique_groups) < num_groups:
+            raise ValueError("initial_partition has a different number of groups than num_groups.")
+
+    # seed
+    if seed is not None and not isinstance(seed, int):
+        raise TypeError("seed must be an integer or None.")
+
+    # num_samples
+    if not isinstance(num_samples, int) or num_samples <= 0:
+        raise ValueError("num_samples must be a positive integer.")
+
+    # beta (non-negative float)
+    if not isinstance(beta, (int, float)) or float(beta) < 0.0:
+        raise ValueError("beta must be a non-negative number.")
+
+    # num_tempering_chains
+    if not isinstance(num_tempering_chains, int) or num_tempering_chains <= 0:
+        raise ValueError("num_tempering_chains must be a positive integer.")
+
+    # no_cache (boolean)
+    if not isinstance(no_cache, bool):
+        raise TypeError("no_cache must be a boolean.")
+
+    # timeout
+    if not isinstance(timeout, (int, float)) or float(timeout) <= 0.0:
+        raise ValueError("timeout must be a positive number (seconds).")
+
+    # verbose
+    if not isinstance(verbose, bool):
+        raise TypeError("verbose must be a boolean.")
+
+    # Passes all checks
+    return None
+
+def _set_model_parameters(model_name: str,
+                   assortative: bool = _UNSET,
+                   mixing_variation: str = _UNSET,
+                   variation_in: Optional[float] = _UNSET,
+                   variation_out: Optional[float] = _UNSET,
+                   degree_correction: Optional[float] = _UNSET,
+                   num_groups: Optional[int] = _UNSET) -> tuple:
+    """
+    Convert the model_name to corresponding non-default parameter values (if not explicitly provided)
+    """
+    model_name = _canonical_model_name(model_name)
+
+    if model_name == 'general_canonical':
+        pass # all parameters take default values
+    elif model_name == 'traditional_SBM':
+        if assortative is _UNSET:
+            assortative = False
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+    elif model_name == 'traditional_DCSBM':
+        if assortative is _UNSET:
+            assortative = False
+        if degree_correction is _UNSET:
+            degree_correction = 0.5
+    elif model_name == 'traditional_GDCSBM':
+        if assortative is _UNSET:
+            assortative = False
+    elif model_name == 'simple_ASBM':
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+    elif model_name == 'hybrid_ASBM':
+        if mixing_variation is _UNSET:
+            mixing_variation = 'internal'
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+    elif model_name == 'planted_partition':
+        if mixing_variation is _UNSET:
+            mixing_variation = 'none'
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+    elif model_name == 'general_ASBM':
+        if mixing_variation is _UNSET:
+            mixing_variation = 'general'
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+    elif model_name == 'microcanonical_SBM':
+        if assortative is _UNSET:
+            assortative = False
+        if degree_correction is _UNSET:
+            degree_correction = 0.0
+        # mean_degree_scaling is fixed to 0.0 and not exposed
+    elif model_name == 'microcanonical_DCSBM':
+        if assortative is _UNSET:
+            assortative = False
+        if degree_correction is _UNSET:
+            degree_correction = 0.5
+        # mean_degree_scaling is fixed to 0.0 and not exposed
+    elif model_name == 'general_unified':
+        # mean_degree_scaling previously inferred here; now fixed to 0.0
+        pass
+    
+    # Set remaining _UNSET parameters to defaults
+    if mixing_variation is _UNSET:
+        mixing_variation = 'general'
+
+    # Implement the mixing_variation presets
+    if mixing_variation == 'general':
+        pass # both inferred
+    elif mixing_variation == 'simple':
+        if variation_in is _UNSET:
+            variation_in = 0.5
+        if variation_out is _UNSET:
+            variation_out = 0.5
+    elif mixing_variation == 'none':
+        if variation_in is _UNSET:
+            variation_in = 0.0
+        if variation_out is _UNSET:
+            variation_out = 0.0
+    elif mixing_variation == 'internal':
+        if variation_in is _UNSET:
+            variation_in = 0.5
+        if variation_out is _UNSET:
+            variation_out = 0.0
+    elif mixing_variation == 'external':
+        if variation_in is _UNSET:
+            variation_in = 0.0
+        if variation_out is _UNSET:
+            variation_out = 0.5
+
+    # Set remaining _UNSET parameters to defaults
+    if assortative is _UNSET:
+        assortative = True
+    if degree_correction is _UNSET:
+        degree_correction = None
+    if num_groups is _UNSET:
+        num_groups = None
+    if variation_in is _UNSET:
+        variation_in = None
+    if variation_out is _UNSET:
+        variation_out = None
+
+    return (assortative, mixing_variation, variation_in, variation_out, degree_correction, num_groups)
+
+# Plot the groups on the network
+# Removed unused plotting and GML helper functions (plot_groups, add_node_group_attribute,
+# write_gml). These helpers were unused and partially implemented; callers should
+# perform plotting or file writing externally if needed.
+
+
+def get_neighbors(G: nx.Graph) -> Iterable[dict]:
+    """
+    Return the neighbors of the graph in a format that can be used by the MCMC algorithm
+    neighbors_list[i] is a dictionary where the keys are the indices of the neighbors of node i
+    and the values are the edge weights
+
+    Parameters
+    ----------
+    G : nx.Graph
+        NetworkX graph to get neighbors for.
+    """
+    node_to_index_dict = {node: i for i, node in enumerate(G.nodes)}
+
+    neighbors_list: list[dict[int, float]] = [dict() for _ in range(G.number_of_nodes())]
+
+    for u, v, data in G.edges(data=True):
+        u_index = node_to_index_dict[u]
+        v_index = node_to_index_dict[v]
+        weight = float(data.get("weight", 1.0))
+        if u_index == v_index:
+            # Self-loop convention: neighbors[i][i] = 2 * actual_weight (both directions).
+            neighbors_list[u_index][u_index] = neighbors_list[u_index].get(u_index, 0.0) + 2.0 * weight
+        else:
+            neighbors_list[u_index][v_index] = neighbors_list[u_index].get(v_index, 0.0) + weight
+            neighbors_list[v_index][u_index] = neighbors_list[v_index].get(u_index, 0.0) + weight
+
+    return neighbors_list

asbm-0.1.4.dev3.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: asbm
+Version: 0.1.4.dev3
+Summary: Find group structures in networks
+Author-Email: Maximilian Jerdee <mjerdee@umich.edu>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/maxjerdee/asbm
+Project-URL: Bug Tracker, https://github.com/maxjerdee/asbm/issues
+Project-URL: Discussions, https://github.com/maxjerdee/asbm/discussions
+Project-URL: Changelog, https://github.com/maxjerdee/asbm/releases
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: tqdm>=4.65.0
+Description-Content-Type: text/markdown
+
+# asbm
+
+[![Documentation Status][rtd-badge]][rtd-link]
+[![PyPI version][pypi-version]][pypi-link]
+[![PyPI platforms][pypi-platforms]][pypi-link]
+
+<!-- SPHINX-START -->
+
+<!-- prettier-ignore-start -->
+[actions-badge]:            https://github.com/maxjerdee/asbm/workflows/CI/badge.svg
+[actions-link]:             https://github.com/maxjerdee/asbm/actions
+[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/asbm
+[conda-link]:               https://github.com/conda-forge/asbm-feedstock
+[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
+[github-discussions-link]:  https://github.com/maxjerdee/asbm/discussions
+[paper-link]:               https://arxiv.org/abs/TODO
+[pypi-link]:                https://pypi.org/project/asbm/
+[pypi-platforms]:           https://img.shields.io/pypi/pyversions/asbm
+[pypi-version]:             https://img.shields.io/pypi/v/asbm
+[rtd-badge]:                https://readthedocs.org/projects/asbm/badge/?version=latest
+[rtd-link]:                 https://asbm.readthedocs.io/en/latest/?badge=latest
+
+<!-- prettier-ignore-end -->
+
+## Infer network groups and properties with assortative stochastic block models
+
+*Maximilian Jerdee*
+
+This Python package uses Bayesian inference to find meaningful groupings of nodes in networks.
+
+We implement a [general assortative SBM][paper-link] that unifies the standard SBM and the planted partition model under a common framework. Its parameters directly measure the violation of each model's assumptions: the assortative preference ρ_in/ρ_out captures departure from in/out symmetry, while per-group variation coefficients v_in and v_out measure heterogeneity across groups. The standard SBM, planted partition model, and the Zhang–Peixoto hybrid emerge as special cases, enabling exact Bayesian model comparison between them.
+
+For each model, the package includes algorithms to:
+- Find consensus estimates of the group structure
+- Infer global network parameters (assortativity, group sizes)
+- Score held-out edges via posterior predictive likelihood
+
+## Installation
+
+Implementations are available for Python, R, and Julia.
+
+### Python
+
+```bash
+pip install asbm
+```
+
+Or build locally from the repository root:
+
+```bash
+pip install .
+```
+
+### R
+
+```r
+install.packages("asbm", repos = "https://maxjerdee.r-universe.dev")
+```
+
+### Julia
+
+```julia
+using Pkg
+Pkg.add(url="https://github.com/maxjerdee/asbm", subdir="bindings/julia")
+```
+
+Building from source requires CMake and a C++17 compiler. Run `Pkg.build("ASBM")` after installation to compile the native library.
+
+## Quickstart
+
+### Python
+
+```python
+import asbm
+import networkx as nx
+
+G = nx.read_gml("examples/data/dolphins.gml", label="id")
+
+config = asbm.Config(
+    model="general_asbm",
+    degree_correction=True,
+)
+
+result = asbm.fit(config, G)
+
+print(result.mdl_partition)
+print(result.mdl_value)
+print(result.consensus_partition())
+```
+
+To score held-out edges:
+
+```python
+G_train = nx.read_gml("examples/data/train.gml")
+G_test  = nx.read_gml("examples/data/test.gml")
+
+result = asbm.fit(asbm.Config(model="general_asbm"), G_train)
+score  = result.log_posterior_predictive(G_test)
+```
+
+### R
+
+```r
+library(asbm)
+library(igraph)
+
+G <- read_graph("examples/data/dolphins.gml", format = "gml")
+
+result <- fit(G,
+              model             = "general_asbm",
+              degree_correction = TRUE,
+              num_chains        = 4,
+              samples_per_chain = 100,
+              seed              = 42)
+
+print(result$mdl_value)
+print(result$mdl_partition)
+print(result$consensus_partition)
+```
+
+### Julia
+
+```julia
+using ASBM, Graphs
+
+g = cycle_graph(62)  # or load via GraphIO
+
+result = fit(g;
+    model             = "general_asbm",
+    degree_correction = true,
+    num_chains        = 4,
+    samples_per_chain = 100,
+    seed              = 42)
+
+println(result.mdl_value)
+println(result.mdl_partition)
+println(result.consensus_partition)
+```
+
+For the full API, including posterior predictive evaluation and the samples schema, see the [package documentation][rtd-link].

asbm-0.1.4.dev3.dist-info/RECORD

@@ -0,0 +1,10 @@
+asbm/__init__.py,sha256=Mhl0eIOXCjR3wWpYwKTu2lVZHqkyBYNDg047JB-Um2U,313
+asbm/_asbm.cp313-win_amd64.pyd,sha256=13xenevjUZbvaLYu3Przwzk6cxgphUt362i4JmFSZhc,413184
+asbm/_version.py,sha256=r5MqpXVcUNROsObvaJ5rDQq1GnaqEXbreKXRuNHxjqU,565
+asbm/core.py,sha256=qvss9eZs9IfcinHw-_9sx4n61z5eysRL7p_3BzRltCc,5246
+asbm/input_output.py,sha256=BEmCLFmaVR1fh4uAtWpVMrB7yyFBZWmYzCDkj9AwIuA,12814
+asbm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asbm-0.1.4.dev3.dist-info/METADATA,sha256=sQx6C18Sgc0l4IZYa0JNDmYvLGh2QJjnbAEsyVWN1Sc,5436
+asbm-0.1.4.dev3.dist-info/WHEEL,sha256=UZrbbE4r80xj7Ncfa6JoeTVe-77bdXLkKUA63V8pKWQ,106
+asbm-0.1.4.dev3.dist-info/licenses/LICENSE,sha256=nXOCnfm201QiVNd89JJAWmzk6cFctyYaVecsfK4kXk8,1076
+asbm-0.1.4.dev3.dist-info/RECORD,,

asbm-0.1.4.dev3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.12.2
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

asbm-0.1.4.dev3.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2025 Maximilian Jerdee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.