lanctools 0.0.0__tar.gz

lanctools-0.0.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Misc
+.coverage

lanctools-0.0.0/.python-version

@@ -0,0 +1 @@
+3.12

lanctools-0.0.0/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.15)
+project(${SKBUILD_PROJECT_NAME} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+find_package(ZLIB REQUIRED)
+
+pybind11_add_module(_cpp
+  src/lanctools/_cpp/bindings.cpp
+  src/lanctools/_cpp/flare.cpp
+  src/lanctools/_cpp/rfmix.cpp
+)
+
+install(TARGETS _cpp DESTINATION ${SKBUILD_PROJECT_NAME})
+
+target_link_libraries(_cpp PRIVATE ZLIB::ZLIB)

lanctools-0.0.0/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

lanctools-0.0.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: lanctools
+Version: 0.0.0
+Summary: Add your description here
+Author-Email: Frank Ockerman <frank.ockerman@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: numba>=0.63.1
+Requires-Dist: numpy>=2.3.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pgenlib>=0.93.0
+Requires-Dist: typer>=0.20.0
+Description-Content-Type: text/markdown
+
+# lanctools
+
+Tools for working with local ancestry data in the `.lanc` file format.
+This package contains two main components:
+
+1. A function (and corresponding CLI) for converting FLARE and RFMix files to
+the .lanc format
+2. A `LancData` class with methods for fast querying of local ancestry and
+local ancestry-masked genotypes
+
+## Installation
+
+```
+pip install lanctools
+```
+
+## Quickstart
+
+To load and query local ancestry data for a set of variants::
+
+```
+import numpy as np
+
+from lanctools import LancData
+
+ld = LancData(
+    plink_prefix="chr1",
+    lanc_file="chr1.lanc",
+    ancestries=["YRI", "CEU"]
+)
+
+idx_var = np.arange(100, dtype=np.uint32)
+
+lanc = ld.get_lanc(idx_var) # (N, 100, 2): phased local ancestry
+geno = ld.get_geno(idx_var) # (N, 100, 2): phased genotypes
+lanc_geno = ld.get_lanc_geno(idx_var) # (N, 100, len(ancestries))
+```
+
+To convert a FLARE (or RFMix) local ancestry file to `.lanc`:
+
+```
+from lanctools import convert_to_lanc
+
+convert_to_lanc(
+    file="chr1.anc.vcf.gz",
+    file_fmt="FLARE",
+    plink_prefix="chr1",
+    output="chr1.lanc"
+)
+```
+
+To perform the above conversion using the CLI tool:
+
+```
+lanctools convert-flare --file chr1.anc.vcf.gz --plink_prefix chr1 --output chr1.lanc
+```

lanctools-0.0.0/README.md

@@ -0,0 +1,56 @@
+# lanctools
+
+Tools for working with local ancestry data in the `.lanc` file format.
+This package contains two main components:
+
+1. A function (and corresponding CLI) for converting FLARE and RFMix files to
+the .lanc format
+2. A `LancData` class with methods for fast querying of local ancestry and
+local ancestry-masked genotypes
+
+## Installation
+
+```
+pip install lanctools
+```
+
+## Quickstart
+
+To load and query local ancestry data for a set of variants::
+
+```
+import numpy as np
+
+from lanctools import LancData
+
+ld = LancData(
+    plink_prefix="chr1",
+    lanc_file="chr1.lanc",
+    ancestries=["YRI", "CEU"]
+)
+
+idx_var = np.arange(100, dtype=np.uint32)
+
+lanc = ld.get_lanc(idx_var) # (N, 100, 2): phased local ancestry
+geno = ld.get_geno(idx_var) # (N, 100, 2): phased genotypes
+lanc_geno = ld.get_lanc_geno(idx_var) # (N, 100, len(ancestries))
+```
+
+To convert a FLARE (or RFMix) local ancestry file to `.lanc`:
+
+```
+from lanctools import convert_to_lanc
+
+convert_to_lanc(
+    file="chr1.anc.vcf.gz",
+    file_fmt="FLARE",
+    plink_prefix="chr1",
+    output="chr1.lanc"
+)
+```
+
+To perform the above conversion using the CLI tool:
+
+```
+lanctools convert-flare --file chr1.anc.vcf.gz --plink_prefix chr1 --output chr1.lanc
+```

lanctools-0.0.0/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

lanctools-0.0.0/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "lanctools"
+version = "0.0.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [{ name = "Frank Ockerman", email = "frank.ockerman@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = [
+  "numba>=0.63.1",
+  "numpy>=2.3.5",
+  "pandas>=2.3.3",
+  "pgenlib>=0.93.0",
+  "typer>=0.20.0",
+]
+
+[tool.scikit-build]
+minimum-version = "build-system.requires"
+build-dir = "build/{wheel_tag}"
+
+wheel.exclude = ["data", "result"]
+sdist.exclude = ["data", "result"]
+
+[tool.uv]
+cache-keys = [
+  { file = "pyproject.toml" },
+  { file = "src/**/*.{h,c,hpp,cpp}" },
+  { file = "CMakeLists.txt" },
+]
+
+[build-system]
+requires = ["scikit-build-core>=0.10", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[dependency-groups]
+dev = [
+  "ipython>=9.6.0",
+  "pytest>=9.0.2",
+  "pytest-cov>=7.0.0",
+  "sphinx>=7,<9",
+  "myst-parser>=2.0.0",
+  "sphinx-autodoc-typehints>=3.5.2",
+  "sphinx-rtd-theme>=3.0.2",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+lanctools = "lanctools.cli:main_entry"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = [
+  "--strict-markers",
+  "--strict-config",
+  "--cov=src",
+  "--cov-report=term-missing",
+]

lanctools-0.0.0/source/conf.py

@@ -0,0 +1,38 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(".."))
+
+
+project = "lanctools"
+copyright = "2025, Franklin Ockerman"
+author = "Franklin Ockerman"
+release = "0.0.0"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
+    "sphinx_autodoc_typehints",
+    "myst_parser",
+]
+
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]

lanctools-0.0.0/source/index.rst

@@ -0,0 +1,17 @@
+.. lanctools documentation master file, created by
+   sphinx-quickstart on Sat Dec 20 23:18:55 2025.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+lanctools
+=========
+
+.. include:: ../README.md
+   :parser: myst_parser.sphinx_
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   lanctools

lanctools-0.0.0/source/lanctools.rst

@@ -0,0 +1,8 @@
+lanctools Package
+====================
+
+.. automodule:: lanctools.core
+    :members:
+    :undoc-members:
+    :show-inheritance:
+

lanctools-0.0.0/src/lanctools/__init__.py

@@ -0,0 +1,4 @@
+from .core import LancData, FlatLanc, convert_to_lanc
+
+__all__ = ["LancData", "FlatLanc", "convert_to_lanc"]
+__version__ = "0.0.0"

lanctools-0.0.0/src/lanctools/_cpp/bindings.cpp

@@ -0,0 +1,11 @@
+#include "flare.hpp"
+#include "rfmix.hpp"
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_cpp, m) {
+  m.doc() = "lanctools C++ backend";
+  bind_rfmix(m);
+  bind_flare(m);
+}

lanctools-0.0.0/src/lanctools/_cpp/flare.cpp

@@ -0,0 +1,261 @@
+#include "flare.hpp"
+#include <cstdint>
+#include <pybind11/stl.h>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <zlib.h>
+
+namespace py = pybind11;
+
+struct AncestryTract {
+  std::string chrom;
+  uint32_t spos;
+  uint32_t epos;
+  uint8_t anc0;
+  uint8_t anc1;
+};
+
+struct VCFRecord {
+  std::string chrom;
+  uint32_t pos;
+  std::vector<uint8_t> anc0;
+  std::vector<uint8_t> anc1;
+
+  VCFRecord(size_t n_samples) : anc0(n_samples, 255), anc1(n_samples, 255) {}
+};
+
+std::string gz_readline(gzFile file) {
+  const size_t chunk_size = 65536;
+  char buffer[chunk_size];
+  std::string line;
+
+  while (gzgets(file, buffer, chunk_size)) {
+    line += buffer;
+    if (!line.empty() && line.back() == '\n')
+      break;
+  }
+
+  while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) {
+    line.pop_back();
+  }
+  return line;
+}
+
+std::vector<std::string> split(const std::string &s, char delim) {
+  std::vector<std::string> elems;
+  std::stringstream ss(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    elems.push_back(item);
+  }
+  return elems;
+}
+
+std::pair<uint8_t, uint8_t>
+extract_AN1_AN2(const std::string &sample_field,
+                const std::vector<std::string> &format_fields, int an1_idx,
+                int an2_idx) {
+  uint8_t missing = 255;
+  std::vector<std::string> tokens = split(sample_field, ':');
+  uint8_t an1 = missing, an2 = missing;
+
+  if (an1_idx >= 0 && an1_idx < (int)tokens.size()) {
+    try {
+      int val = std::stoi(tokens[an1_idx]);
+      if (val >= 0 && val <= 255)
+        an1 = val;
+    } catch (...) {
+    }
+  }
+  if (an2_idx >= 0 && an2_idx < (int)tokens.size()) {
+    try {
+      int val = std::stoi(tokens[an2_idx]);
+      if (val >= 0 && val <= 255)
+        an2 = val;
+    } catch (...) {
+    }
+  }
+  return {an1, an2};
+}
+
+VCFRecord construct_vcf_record(const std::vector<std::string> &fields,
+                               const std::vector<std::string> &format_fields,
+                               int an1_idx, int an2_idx, int format_idx,
+                               int n_samples, const std::string &chrom,
+                               uint32_t pos) {
+  VCFRecord record(n_samples);
+  record.chrom = chrom;
+  record.pos = pos;
+  for (int i = 0; i < n_samples; ++i) {
+    auto [an1, an2] = extract_AN1_AN2(fields[format_idx + 1 + i], format_fields,
+                                      an1_idx, an2_idx);
+    record.anc0[i] = an1;
+    record.anc1[i] = an2;
+  }
+  return record;
+}
+
+void finalize_open_tracts(
+    const std::vector<std::string> &sample_ids,
+    const std::vector<uint8_t> &prev_anc,
+    const std::vector<uint32_t> &prev_spos,
+    std::unordered_map<std::string, std::vector<AncestryTract>> &sample_tracts,
+    const std::string &chrom, uint32_t final_pos) {
+  for (size_t i = 0; i < sample_ids.size(); ++i) {
+    const std::string &sample = sample_ids[i];
+    uint8_t anc0 = prev_anc[i * 2];
+    uint8_t anc1 = prev_anc[i * 2 + 1];
+    if (anc0 != 255 || anc1 != 255) {
+      sample_tracts[sample].push_back(
+          {chrom, prev_spos[i * 2], final_pos, anc0, anc1});
+    }
+  }
+}
+
+py::dict read_flare(const std::string &flare_file) {
+  gzFile file = gzopen(flare_file.c_str(), "rb");
+  if (!file)
+    throw std::runtime_error("Failed to open input VCF file");
+
+  std::string line;
+  bool found_header = false;
+  while (!(line = gz_readline(file)).empty()) {
+    if (line.substr(0, 6) == "#CHROM") {
+      found_header = true;
+      break;
+    }
+  }
+  if (!found_header) {
+    gzclose(file);
+    throw std::runtime_error("Missing #CHROM header line");
+  }
+
+  std::vector<std::string> header_fields = split(line, '\t');
+  int chrom_idx = -1, pos_idx = -1, format_idx = -1;
+  for (size_t i = 0; i < header_fields.size(); ++i) {
+    if (header_fields[i] == "#CHROM")
+      chrom_idx = i;
+    else if (header_fields[i] == "POS")
+      pos_idx = i;
+    else if (header_fields[i] == "FORMAT")
+      format_idx = i;
+  }
+  if (chrom_idx == -1 || pos_idx == -1 || format_idx == -1) {
+    gzclose(file);
+    throw std::runtime_error("Missing essential VCF columns");
+  }
+
+  std::vector<std::string> sample_ids(header_fields.begin() + format_idx + 1,
+                                      header_fields.end());
+  int n_samples = sample_ids.size();
+
+  std::unordered_map<std::string, std::vector<AncestryTract>> sample_tracts;
+  std::vector<uint8_t> prev_anc(n_samples * 2, 255);
+  std::vector<uint32_t> prev_spos(n_samples * 2, 0);
+  uint32_t cur_pos = 0, prev_pos = 0;
+  std::string cur_chrom = "chr0";
+  bool is_first_record = true;
+
+  while (!(line = gz_readline(file)).empty()) {
+    if (line.empty() || line[0] == '#')
+      continue;
+
+    std::vector<std::string> fields = split(line, '\t');
+    if (fields.size() < format_idx + 1 + n_samples)
+      continue;
+
+    std::string chrom = fields[chrom_idx];
+    uint32_t pos = std::stoul(fields[pos_idx]);
+
+    std::vector<std::string> format_fields = split(fields[format_idx], ':');
+    int an1_idx = -1, an2_idx = -1;
+    for (size_t i = 0; i < format_fields.size(); ++i) {
+      if (format_fields[i] == "AN1")
+        an1_idx = i;
+      else if (format_fields[i] == "AN2")
+        an2_idx = i;
+    }
+
+    VCFRecord record =
+        construct_vcf_record(fields, format_fields, an1_idx, an2_idx,
+                             format_idx, n_samples, chrom, pos);
+
+    prev_pos = cur_pos;
+    cur_pos = pos;
+
+    if (is_first_record) {
+      for (size_t i = 0; i < n_samples; ++i) {
+        prev_spos[i * 2] = pos;
+        prev_spos[i * 2 + 1] = pos;
+        prev_anc[i * 2] = record.anc0[i];
+        prev_anc[i * 2 + 1] = record.anc1[i];
+      }
+      cur_chrom = chrom;
+      is_first_record = false;
+      continue;
+    }
+
+    if (chrom != cur_chrom) {
+      finalize_open_tracts(sample_ids, prev_anc, prev_spos, sample_tracts,
+                           cur_chrom, pos - 1);
+      for (size_t i = 0; i < n_samples; ++i) {
+        prev_spos[i * 2] = pos;
+        prev_spos[i * 2 + 1] = pos;
+        prev_anc[i * 2] = record.anc0[i];
+        prev_anc[i * 2 + 1] = record.anc1[i];
+      }
+      cur_chrom = chrom;
+      continue;
+    }
+
+    for (size_t i = 0; i < n_samples; ++i) {
+      size_t idx0 = i * 2, idx1 = i * 2 + 1;
+      uint8_t new_anc0 = record.anc0[i];
+      uint8_t new_anc1 = record.anc1[i];
+      if (new_anc0 != prev_anc[idx0] || new_anc1 != prev_anc[idx1]) {
+        uint32_t midpoint = prev_pos + (cur_pos - prev_pos) / 2;
+        sample_tracts[sample_ids[i]].push_back(
+            {chrom, prev_spos[idx0], midpoint, prev_anc[idx0], prev_anc[idx1]});
+        prev_spos[idx0] = midpoint + 1;
+        prev_anc[idx0] = new_anc0;
+        prev_anc[idx1] = new_anc1;
+      }
+    }
+  }
+  gzclose(file);
+  finalize_open_tracts(sample_ids, prev_anc, prev_spos, sample_tracts,
+                       cur_chrom, cur_pos);
+
+  py::dict result;
+
+  std::vector<std::string> samples, chroms;
+  std::vector<uint32_t> spos_vec, epos_vec;
+  std::vector<int> anc0_vec, anc1_vec;
+
+  for (const auto &[sample, tracts] : sample_tracts) {
+    for (const auto &tract : tracts) {
+      samples.push_back(sample);
+      chroms.push_back(tract.chrom);
+      spos_vec.push_back(tract.spos);
+      epos_vec.push_back(tract.epos);
+      anc0_vec.push_back(static_cast<int>(tract.anc0));
+      anc1_vec.push_back(static_cast<int>(tract.anc1));
+    }
+  }
+
+  result["sample"] = samples;
+  result["chrom"] = chroms;
+  result["spos"] = spos_vec;
+  result["epos"] = epos_vec;
+  result["anc0"] = anc0_vec;
+  result["anc1"] = anc1_vec;
+
+  return result;
+}
+
+void bind_flare(py::module_ &m) {
+  m.def("read_flare", &read_flare, "Read FLARE VCF and return ancestry tracts");
+}

lanctools-0.0.0/src/lanctools/_cpp/flare.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+py::dict read_flare(const std::string &flare_file);
+void bind_flare(py::module_ &m);