bedspec 0.6.0__py3-none-any.whl

CONTRIBUTING.md

@@ -0,0 +1,94 @@
+# Development and Testing
+
+## Primary Development Commands
+
+To check and resolve linting issues in the codebase, run:
+
+```console
+poetry run ruff check --fix
+```
+
+To check and resolve formatting issues in the codebase, run:
+
+```console
+poetry run ruff format
+```
+
+To check the unit tests in the codebase, run:
+
+```console
+poetry run pytest
+```
+
+To check the typing in the codebase, run:
+
+```console
+poetry run mypy
+```
+
+To generate a code coverage report after testing locally, run:
+
+```console
+poetry run coverage html
+```
+
+To check the lock file is up-to-date:
+
+```console
+poetry check --lock
+```
+
+## Shortcut Task Commands
+
+To be able to run shortcut task commands, first install the Poetry plugin [`poethepoet`](https://poethepoet.natn.io/index.html):
+
+```console
+poetry self add 'poethepoet[poetry_plugin]'
+```
+
+> [!NOTE]
+> Upon the release of Poetry [v2.0.0](https://github.com/orgs/python-poetry/discussions/9793#discussioncomment-11043205), Poetry will automatically support bootstrap installation of [project-specific plugins](https://github.com/python-poetry/poetry/pull/9547) and installation of the task runner will become automatic for this project.
+> The `pyproject.toml` syntax will be:
+> 
+> ```toml
+> [tool.poetry]
+> requires-poetry = ">=2.0"
+> 
+> [tool.poetry.requires-plugins]
+> poethepoet = ">=0.29"
+> ```
+
+### For Running Individual Checks
+
+```console
+poetry task check-lock
+poetry task check-format
+poetry task check-lint
+poetry task check-tests
+poetry task check-typing
+```
+
+### For Running All Checks
+
+```console
+poetry task check-all
+```
+
+### For Running Individual Fixes
+
+```console
+poetry task fix-format
+poetry task fix-lint
+```
+
+### For Running All Fixes
+
+```console
+poetry task fix-all
+```
+
+### For Running All Fixes and Checks
+
+```console
+poetry task fix-and-check-all
+```

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2024 Clint Valentine
+
+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.

bedspec/__init__.py

@@ -0,0 +1,43 @@
+from ._bedspec import Bed2
+from ._bedspec import Bed3
+from ._bedspec import Bed4
+from ._bedspec import Bed5
+from ._bedspec import Bed6
+from ._bedspec import Bed12
+from ._bedspec import BedColor
+from ._bedspec import BedGraph
+from ._bedspec import BedLike
+from ._bedspec import BedPE
+from ._bedspec import BedStrand
+from ._bedspec import BedType
+from ._bedspec import Named
+from ._bedspec import PairBed
+from ._bedspec import PointBed
+from ._bedspec import ReferenceSpan
+from ._bedspec import SimpleBed
+from ._bedspec import Stranded
+from ._reader import BedReader
+from ._writer import BedWriter
+
+__all__ = [
+    "Bed2",
+    "Bed3",
+    "Bed4",
+    "Bed5",
+    "Bed6",
+    "Bed12",
+    "BedColor",
+    "BedGraph",
+    "BedLike",
+    "BedPE",
+    "BedStrand",
+    "BedType",
+    "Named",
+    "PairBed",
+    "PointBed",
+    "ReferenceSpan",
+    "SimpleBed",
+    "Stranded",
+    "BedReader",
+    "BedWriter",
+]

bedspec/_bedspec.py

@@ -0,0 +1,370 @@
+import dataclasses
+from abc import ABC
+from abc import abstractmethod
+from collections.abc import Iterator
+from dataclasses import Field
+from dataclasses import dataclass
+from dataclasses import field
+from enum import Enum
+from enum import unique
+from typing import Any
+from typing import ClassVar
+from typing import Protocol
+from typing import TypeVar
+from typing import final
+from typing import runtime_checkable
+
+from typing_extensions import Self
+from typing_extensions import override
+
+COMMENT_PREFIXES: set[str] = {"#", "browser", "track"}
+"""The set of BED comment prefixes that this library supports."""
+
+MISSING_FIELD: str = "."
+"""The string used to indicate a missing field in a BED record."""
+
+
+@runtime_checkable
+class DataclassInstance(Protocol):
+    """A protocol for objects that are dataclass instances."""
+
+    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
+
+
+@unique
+class BedStrand(str, Enum):
+    """BED strands for forward and reverse orientations."""
+
+    Positive = "+"
+    """The positive BED strand."""
+
+    Negative = "-"
+    """The negative BED strand."""
+
+    def opposite(self) -> "BedStrand":
+        """Return the opposite BED strand."""
+        if self is BedStrand.Positive:
+            return BedStrand.Negative
+        else:
+            return BedStrand.Positive
+
+    @override
+    def __str__(self) -> str:
+        """Return this strand as a string."""
+        return self.value
+
+
+@runtime_checkable
+class ReferenceSpan(Protocol):
+    """A structural protocol for 0-based half-open objects located on a reference sequence."""
+
+    refname: str
+    start: int
+    end: int
+
+
+@runtime_checkable
+class Named(Protocol):
+    """A structural protocol for a named BED type."""
+
+    name: str | None
+
+
+@runtime_checkable
+class Stranded(Protocol):
+    """A structural protocol for stranded BED types."""
+
+    strand: BedStrand | None
+
+
+class BedLike(ABC, DataclassInstance):
+    """An abstract base class for all types of BED records."""
+
+    @abstractmethod
+    def territory(self) -> Iterator[ReferenceSpan]:
+        """Return intervals that describe the territory of this BED record."""
+
+
+BedType = TypeVar("BedType", bound=BedLike)
+"""A type variable for any kind of BED record type."""
+
+
+@dataclass
+class PointBed(BedLike, ABC):
+    """An abstract class for a BED record that describes a 0-based 1-length point."""
+
+    refname: str
+    start: int
+
+    def __init_subclass__(cls) -> None:
+        if not dataclasses.is_dataclass(cls):
+            raise TypeError("You must annotate custom BED class definitions with @dataclass!")
+        return super().__init_subclass__()
+
+    @final
+    def __len__(self) -> int:
+        """The length of this record."""
+        return 1
+
+    @override
+    def territory(self) -> Iterator[ReferenceSpan]:
+        """Return the territory of a single point BED record which is 1-length."""
+        yield Bed3(refname=self.refname, start=self.start, end=self.start + 1)
+
+
+@dataclass
+class SimpleBed(BedLike, ReferenceSpan, ABC):
+    """An abstract class for a BED record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int
+    end: int
+
+    def __init_subclass__(cls) -> None:
+        if not dataclasses.is_dataclass(cls):
+            raise TypeError("You must annotate custom BED class definitions with @dataclass!")
+        return super().__init_subclass__()
+
+    def __post_init__(self) -> None:
+        """Validate this linear BED record."""
+        if self.start >= self.end or self.start < 0:
+            raise ValueError("start must be greater than 0 and less than end!")
+
+    @final
+    def __len__(self) -> int:
+        """The length of this record."""
+        return self.end - self.start
+
+    @override
+    def territory(self) -> Iterator[ReferenceSpan]:
+        """Return the territory of a linear BED record which is just itself."""
+        yield self
+
+
+@dataclass
+class PairBed(BedLike, ABC):
+    """An abstract base class for a BED record that describes a pair of linear linear intervals."""
+
+    refname1: str
+    start1: int
+    end1: int
+    refname2: str
+    start2: int
+    end2: int
+
+    def __init_subclass__(cls) -> None:
+        if not dataclasses.is_dataclass(cls):
+            raise TypeError("You must annotate custom BED class definitions with @dataclass!")
+        return super().__init_subclass__()
+
+    def __post_init__(self) -> None:
+        """Validate this pair of BED records."""
+        if self.start1 >= self.end1 or self.start1 < 0:
+            raise ValueError("start1 must be greater than 0 and less than end1!")
+        if self.start2 >= self.end2 or self.start2 < 0:
+            raise ValueError("start2 must be greater than 0 and less than end2!")
+
+    @property
+    def bed1(self) -> SimpleBed:
+        """The first of the two intervals."""
+        return Bed3(refname=self.refname1, start=self.start1, end=self.end1)
+
+    @property
+    def bed2(self) -> SimpleBed:
+        """The second of the two intervals."""
+        return Bed3(refname=self.refname2, start=self.start2, end=self.end2)
+
+    @override
+    def territory(self) -> Iterator[ReferenceSpan]:
+        """Return the territory of this BED record which are two intervals."""
+        yield self.bed1
+        yield self.bed2
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class BedColor:
+    """The color of a BED record in red, green, and blue color values."""
+
+    r: int
+    g: int
+    b: int
+
+    def __post_init__(self) -> None:
+        """Validate that all color values are well-formatted."""
+        if any(value > 255 or value < 0 for value in (self.r, self.g, self.b)):
+            raise ValueError(f"RGB color values must be in the range [0, 255] but found: {self}")
+
+    @classmethod
+    def from_string(cls, string: str) -> Self:
+        """Build a BED color instance from a string."""
+        try:
+            r, g, b = map(int, string.split(","))
+        except ValueError as error:
+            raise ValueError(f"Invalid string '{string}'. Expected 'int,int,int'!") from error
+        return cls(r, g, b)
+
+    @override
+    def __str__(self) -> str:
+        """Return a comma-delimited string representation of this BED color."""
+        return f"{self.r},{self.g},{self.b}"
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed2(PointBed):
+    """A BED2 record that describes a single 0-based 1-length point."""
+
+    refname: str
+    start: int
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed3(SimpleBed):
+    """A BED3 record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed4(SimpleBed):
+    """A BED4 record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+    name: str | None = field(kw_only=True)
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed5(SimpleBed, Named):
+    """A BED5 record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+    name: str | None = field(kw_only=True)
+    score: int | None = field(kw_only=True)
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed6(SimpleBed, Named, Stranded):
+    """A BED6 record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+    name: str | None = field(kw_only=True)
+    score: int | None = field(kw_only=True)
+    strand: BedStrand | None = field(kw_only=True)
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class Bed12(SimpleBed, Named, Stranded):
+    """A BED12 record that describes a contiguous linear interval."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+    name: str | None = field(kw_only=True)
+    score: int | None = field(kw_only=True)
+    strand: BedStrand | None = field(kw_only=True)
+    thick_start: int | None = field(kw_only=True)
+    thick_end: int | None = field(kw_only=True)
+    item_rgb: BedColor | None = field(kw_only=True)
+    block_count: int | None = field(kw_only=True)
+    block_sizes: list[int] | None = field(kw_only=True)
+    block_starts: list[int] | None = field(kw_only=True)
+
+    def __post_init__(self) -> None:
+        """Validate this BED12 record."""
+        super(Bed12, self).__post_init__()
+        if (self.thick_start is None) != (self.thick_end is None):
+            raise ValueError("thick_start and thick_end must both be None or both be set!")
+        if self.block_count is None:
+            if self.block_sizes is not None or self.block_starts is not None:
+                raise ValueError("block_count, block_sizes, block_starts must all be set or unset!")
+        else:
+            if self.block_sizes is None or self.block_starts is None:
+                raise ValueError("block_count, block_sizes, block_starts must all be set or unset!")
+            if self.block_count <= 0:
+                raise ValueError("When set, block_count must be greater than or equal to 1!")
+            if self.block_count != len(self.block_sizes) or self.block_count != len(
+                self.block_starts
+            ):
+                raise ValueError("Length of block_sizes and block_starts must equal block_count!")
+            if self.block_starts[0] != 0:
+                raise ValueError("block_starts must start with 0!")
+            if any(size <= 0 for size in self.block_sizes):
+                raise ValueError("All sizes in block_size must be greater than or equal to one!")
+            if (self.start + self.block_starts[-1] + self.block_sizes[-1]) != self.end:
+                raise ValueError("The last defined block's end must be equal to the BED end!")
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class BedGraph(SimpleBed):
+    """A bedGraph feature for continuous-valued data."""
+
+    refname: str
+    start: int = field(kw_only=True)
+    end: int = field(kw_only=True)
+    value: float = field(kw_only=True)
+
+
+@dataclass(slots=True, unsafe_hash=True)
+class BedPE(PairBed, Named):
+    """A BED record that describes a pair of BED records as per the bedtools spec."""
+
+    refname1: str = field(kw_only=True)
+    start1: int = field(kw_only=True)
+    end1: int = field(kw_only=True)
+    refname2: str = field(kw_only=True)
+    start2: int = field(kw_only=True)
+    end2: int = field(kw_only=True)
+    name: str | None = field(kw_only=True)
+    score: int | None = field(kw_only=True)
+    strand1: BedStrand | None = field(kw_only=True)
+    strand2: BedStrand | None = field(kw_only=True)
+
+    @property
+    @override
+    def bed1(self) -> Bed6:
+        """The first of the two intervals as a BED6 record."""
+        return Bed6(
+            refname=self.refname1,
+            start=self.start1,
+            end=self.end1,
+            name=self.name,
+            score=self.score,
+            strand=self.strand1,
+        )
+
+    @property
+    @override
+    def bed2(self) -> Bed6:
+        """The second of the two intervals as a BED6 record."""
+        return Bed6(
+            refname=self.refname2,
+            start=self.start2,
+            end=self.end2,
+            name=self.name,
+            score=self.score,
+            strand=self.strand2,
+        )
+
+    @classmethod
+    def from_bed6(
+        cls, bed1: Bed6, bed2: Bed6, name: str | None = None, score: int | None = None
+    ) -> Self:
+        return cls(
+            refname1=bed1.refname,
+            start1=bed1.start,
+            end1=bed1.end,
+            refname2=bed2.refname,
+            start2=bed2.start,
+            end2=bed2.end,
+            name=name,
+            score=score,
+            strand1=bed1.strand,
+            strand2=bed2.strand,
+        )

bedspec/_reader.py

@@ -0,0 +1,94 @@
+from io import TextIOWrapper
+from pathlib import Path
+from types import NoneType
+from types import UnionType
+from typing import Any
+from typing import get_args
+from typing import get_origin
+
+from typeline import TsvRecordReader
+from typing_extensions import Self
+from typing_extensions import override
+
+from bedspec._bedspec import COMMENT_PREFIXES
+from bedspec._bedspec import MISSING_FIELD
+from bedspec._bedspec import BedColor
+from bedspec._bedspec import BedStrand
+from bedspec._bedspec import BedType
+
+
+class BedReader(TsvRecordReader[BedType]):
+    """A reader of BED records."""
+
+    @override
+    def __init__(
+        self,
+        handle: TextIOWrapper,
+        record_type: type[BedType],
+        /,
+        header: bool = False,
+        comment_prefixes: set[str] = COMMENT_PREFIXES,
+    ):
+        """Instantiate a new BED reader.
+
+        Args:
+            handle: a file-like object to read delimited data from.
+            record_type: the type of BED record we will be writing.
+            header: whether we expect the first line to be a header or not.
+            comment_prefixes: skip lines that have any of these string prefixes.
+        """
+        super().__init__(handle, record_type, header=header, comment_prefixes=comment_prefixes)
+
+    @override
+    def _decode(self, field_type: type[Any] | str | Any, item: str) -> str:
+        """A callback for overriding the string formatting of builtin and custom types."""
+        if field_type is BedStrand:
+            return f'"{item}"'
+        elif field_type is BedColor:
+            color = BedColor.from_string(item)
+            return f'{{"r":{color.r},"g":{color.g},"b":{color.b}}}'
+
+        is_union: bool = isinstance(field_type, UnionType)
+        type_args: tuple[type, ...] = get_args(field_type)
+        is_optional: bool = is_union and NoneType in type_args
+
+        if is_optional:
+            if item == MISSING_FIELD:
+                return "null"
+            elif type_args.count(BedStrand) == 1:
+                return f'"{item}"'
+            elif type_args.count(BedColor) == 1:
+                if item == "0":
+                    return "null"
+                else:
+                    color = BedColor.from_string(item)
+                    return f'{{"r":{color.r},"g":{color.g},"b":{color.b}}}'
+
+        type_origin: type | None = get_origin(field_type)
+
+        if type_origin in (frozenset, list, set, tuple):
+            return f"[{item.rstrip(',')}]"
+
+        return super()._decode(field_type, item=item)
+
+    @classmethod
+    @override
+    def from_path(
+        cls,
+        path: Path | str,
+        record_type: type[BedType],
+        /,
+        header: bool = False,
+        comment_prefixes: set[str] = COMMENT_PREFIXES,
+    ) -> Self:
+        """Construct a BED reader from a file path.
+
+        Args:
+            path: the path to the file to read delimited data from.
+            record_type: the type of the object we will be writing.
+            header: whether we expect the first line to be a header or not.
+            comment_prefixes: skip lines that have any of these string prefixes.
+        """
+        handle = Path(path).open("r")
+        reader = cls(handle, record_type, header=header, comment_prefixes=comment_prefixes)
+        return reader

bedspec/_writer.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+from typeline import TsvRecordWriter
+from typing_extensions import override
+
+from bedspec._bedspec import COMMENT_PREFIXES
+from bedspec._bedspec import BedColor
+from bedspec._bedspec import BedType
+
+
+class BedWriter(TsvRecordWriter[BedType]):
+    """A writer for writing dataclasses into BED text data."""
+
+    @override
+    def _encode(self, item: Any) -> Any:
+        """A callback for overriding the encoding of builtin types and custom types."""
+        if item is None:
+            return "."
+        elif isinstance(item, (frozenset, list, set, tuple)):
+            return ",".join(map(str, item))  # pyright: ignore[reportUnknownArgumentType]
+        elif isinstance(item, BedColor):
+            return str(item)
+        return super()._encode(item=item)
+
+    def write_comment(self, comment: str) -> None:
+        """Write a comment to the BED output."""
+        for line in comment.splitlines():
+            prefix = "" if any(line.startswith(prefix) for prefix in COMMENT_PREFIXES) else "# "
+            _ = self._handle.write(f"{prefix}{line}\n")

bedspec/overlap/__init__.py

@@ -0,0 +1,5 @@
+from ._overlap import OverlapDetector
+
+__all__ = [
+    "OverlapDetector",
+]

bedspec/overlap/_overlap.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+from collections.abc import Iterable
+from collections.abc import Iterator
+from itertools import chain
+from typing import Generic
+from typing import TypeAlias
+from typing import TypeVar
+
+from superintervals import (  # type: ignore[import-untyped]  # pyright: ignore[reportMissingTypeStubs]
+    IntervalSet,  # pyright: ignore[reportUnknownVariableType]
+)
+from typing_extensions import override
+
+from bedspec._bedspec import ReferenceSpan
+
+ReferenceSpanType = TypeVar("ReferenceSpanType", bound=ReferenceSpan)
+"""Type variable for features stored within the overlap detector."""
+
+Refname: TypeAlias = str
+"""A type alias for a reference sequence name string."""
+
+IntervalTree: TypeAlias = IntervalSet  # pyright: ignore[reportUnknownVariableType]
+"""A type alias for the untyped interval set."""
+
+
+class OverlapDetector(Iterable[ReferenceSpanType], Generic[ReferenceSpanType]):
+    """Detects and returns overlaps between a collection of reference features and query feature.
+
+    The overlap detector may be built with any feature-like Python object that has the following
+    properties:
+
+      * `refname`: The reference sequence name
+      * `start`: A 0-based start position
+      * `end`: A 0-based half-open end position
+
+    This detector is most efficiently used when all features to be queried are added ahead of time.
+    """
+
+    def __init__(self, features: Iterable[ReferenceSpanType] | None = None) -> None:
+        self._refname_to_features: dict[Refname, list[ReferenceSpanType]] = defaultdict(list)
+        self._refname_to_tree: dict[Refname, IntervalTree] = defaultdict(IntervalTree)  # pyright: ignore[reportUnknownArgumentType]
+        self._refname_to_is_indexed: dict[Refname, bool] = defaultdict(lambda: False)
+        if features is not None:
+            self.add(*features)
+
+    @override
+    def __iter__(self) -> Iterator[ReferenceSpanType]:
+        """Iterate over the features in the overlap detector."""
+        return chain(*self._refname_to_features.values())
+
+    def add(self, *features: ReferenceSpanType) -> None:
+        """Add a feature to this overlap detector."""
+        for feature in features:
+            refname: Refname = feature.refname
+            feature_index: int = len(self._refname_to_features[refname])
+
+            self._refname_to_features[refname].append(feature)
+            self._refname_to_tree[refname].add(feature.start, feature.end - 1, feature_index)  # pyright: ignore[reportUnknownMemberType]
+            self._refname_to_is_indexed[refname] = False  # mark that this tree needs re-indexing
+
+    def overlapping(self, feature: ReferenceSpan) -> Iterator[ReferenceSpanType]:
+        """Yields all the overlapping features for a given query feature."""
+        refname: Refname = feature.refname
+
+        if refname in self._refname_to_tree.keys() and not self._refname_to_is_indexed[refname]:  # pyright: ignore[reportUnknownMemberType]
+            self._refname_to_tree[refname].index()  # pyright: ignore[reportUnknownMemberType]
+
+        index: int
+        for index in self._refname_to_tree[refname].find_overlaps(feature.start, feature.end - 1):  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            yield self._refname_to_features[refname][index]
+
+    def overlaps(self, feature: ReferenceSpan) -> bool:
+        """Determine if a query feature overlaps any other features."""
+        return next(self.overlapping(feature), None) is not None
+
+    def enclosing(self, feature: ReferenceSpan) -> Iterator[ReferenceSpanType]:
+        """Yields all the overlapping features that completely enclose the given query feature."""
+        for overlap in self.overlapping(feature):
+            if feature.start >= overlap.start and feature.end <= overlap.end:
+                yield overlap
+
+    def enclosed_by(self, feature: ReferenceSpan) -> Iterator[ReferenceSpanType]:
+        """Yields all the overlapping features that are enclosed by the given query feature."""
+        for overlap in self.overlapping(feature):
+            if feature.start <= overlap.start and feature.end >= overlap.end:
+                yield overlap

bedspec-0.6.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2024 Clint Valentine
+
+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.

bedspec-0.6.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.1
+Name: bedspec
+Version: 0.6.0
+Summary: An HTS-specs compliant BED toolkit.
+Home-page: https://github.com/clintval/bedspec
+License: MIT
+Keywords: bioinformatics,BED,NGS,HTS,interval
+Author: Clint Valentine
+Author-email: valentine.clint@gmail.com
+Requires-Python: >=3.10.0,<4.0.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: File Formats
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: superintervals (>=0.2.2,<0.3.0)
+Requires-Dist: typeline (>=0.6,<0.7)
+Requires-Dist: typing-extensions (>=4.12,<5.0)
+Project-URL: Repository, https://github.com/clintval/bedspec
+Description-Content-Type: text/markdown
+
+# bedspec
+
+[![PyPi Release](https://badge.fury.io/py/bedspec.svg)](https://badge.fury.io/py/bedspec)
+[![CI](https://github.com/clintval/bedspec/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/clintval/bedspec/actions/workflows/tests.yml?query=branch%3Amain)
+[![Python Versions](https://img.shields.io/badge/python-3.10_|_3.11_|_3.12-blue)](https://github.com/clintval/typeline)
+[![basedpyright](https://img.shields.io/badge/basedpyright-checked-42b983)](https://docs.basedpyright.com/latest/)
+[![mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)
+
+An HTS-specs compliant BED toolkit.
+
+## Installation
+
+The package can be installed with `pip`:
+
+```console
+pip install bedspec
+```
+
+## Quickstart
+
+### Building a BED Feature
+
+```pycon
+>>> from bedspec import Bed3
+>>> 
+>>> bed = Bed3("chr1", start=2, end=8)
+
+```
+
+### Writing
+
+```pycon
+>>> from bedspec import BedWriter
+>>> from tempfile import NamedTemporaryFile
+>>> 
+>>> temp_file = NamedTemporaryFile(mode="w+t", suffix=".txt")
+>>>
+>>> with BedWriter.from_path(temp_file.name, Bed3) as writer:
+...     writer.write(bed)
+
+```
+
+### Reading
+
+```pycon
+>>> from bedspec import BedReader
+>>> 
+>>> with BedReader.from_path(temp_file.name, Bed3) as reader:
+...     for bed in reader:
+...         print(bed)
+Bed3(refname='chr1', start=2, end=8)
+
+```
+
+### BED Types
+
+This package provides builtin classes for the following BED formats:
+
+```pycon
+>>> from bedspec import Bed2
+>>> from bedspec import Bed3
+>>> from bedspec import Bed4
+>>> from bedspec import Bed5
+>>> from bedspec import Bed6
+>>> from bedspec import Bed12
+>>> from bedspec import BedGraph
+>>> from bedspec import BedPE
+
+```
+
+### Overlap Detection
+
+Use a fast overlap detector for any collection of interval types, including third-party:
+
+```pycon
+>>> from bedspec import Bed3, Bed4
+>>> from bedspec.overlap import OverlapDetector
+>>>
+>>> bed1 = Bed3("chr1", start=1, end=4)
+>>> bed2 = Bed3("chr1", start=5, end=9)
+>>> 
+>>> detector = OverlapDetector[Bed3]([bed1, bed2])
+>>> 
+>>> my_feature = Bed4("chr1", start=2, end=3, name="hi-mom")
+>>> detector.overlaps(my_feature)
+True
+
+```
+
+The overlap detector supports the following operations:
+
+- `overlapping`: return all overlapping features
+- `overlaps`: test if any overlapping features exist
+- `enclosed_by`: return those enclosed by the input feature
+- `enclosing`: return those enclosing the input feature
+
+### Custom BED Types
+
+To create a custom BED record, inherit from the relevant BED-type (`PointBed`, `SimpleBed`, `PairBed`).
+
+For example, to create a custom BED3+1 class:
+
+```pycon
+>>> from dataclasses import dataclass
+>>> 
+>>> from bedspec import SimpleBed
+>>> 
+>>> @dataclass
+... class Bed3Plus1(SimpleBed):
+...     refname: str
+...     start: int
+...     end: int
+...     my_custom_field: float | None
+
+```
+
+## Development and Testing
+
+See the [contributing guide](./CONTRIBUTING.md) for more information.
+

bedspec-0.6.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+CONTRIBUTING.md,sha256=selnIsM_6KTwdFyc0B3u4n2bM_sBAeSbQV-Fd7mzHuE,1803
+LICENSE,sha256=nN9Rgc41QgFz1uJfX7AsXRQJxlcJotVEPTNPwUAqfys,1070
+bedspec/__init__.py,sha256=MWneXWftcndpg-cSUkbLwuPMty0klBf_SpaaRm0jgKM,907
+bedspec/_bedspec.py,sha256=5JypI3D9q1Jp326CHhU8v3hy9XONJv5Q79qc-2RRhzE,11721
+bedspec/_reader.py,sha256=y4MqHYHvNwE-vk5Kpx2KP6PXtjc00S_D0fgE9hejzYU,3265
+bedspec/_writer.py,sha256=KsF4A2q_fgCNFLnskEwyFW4NMwkF0JcXtrbvJ5UXbBI,1082
+bedspec/overlap/__init__.py,sha256=aArIVkYIMBBC7YZkPP7KPcy6FjPZdKVl0Yi2as4pWNQ,76
+bedspec/overlap/_overlap.py,sha256=s3yROqIs3AcJeCMdLWXBy4eoBz1aytGIwuQG33e-fcY,4153
+bedspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bedspec-0.6.0.dist-info/LICENSE,sha256=nN9Rgc41QgFz1uJfX7AsXRQJxlcJotVEPTNPwUAqfys,1070
+bedspec-0.6.0.dist-info/METADATA,sha256=5yEWscD0bkFQHxJ_5mWKfZQ9R29aVvKgtbXFn9ANdkg,4547
+bedspec-0.6.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+bedspec-0.6.0.dist-info/RECORD,,

bedspec-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any