Changed to use a tileset rather than track constructor for local tile data

Author: pkerpedjiev

src/higlass/__init__.py

@@ -31,6 +31,7 @@
 )
 from higlass.server import HiGlassServer
 from higlass.tilesets import (
+    LocalDataTileset,
     Tileset,
     bed2ddb,
     beddb,

src/higlass/api.py

@@ -120,61 +120,16 @@ def opts(
         return track
 
 
-class _LocalDataMixin:
-    def local_data(
-        self: TrackT,  # type: ignore
-        tsinfo,
-        data,
-        inplace: bool = False,
-    ) -> TrackT:  # type: ignore
-        """Configures local data for a Track.
-
-        Parameters
-        ----------
-        tsinfo : dict
-            Tileset info to be placed under ["tilesetInfo"]["x"].
-        data : list
-            Tile data to be placed under ["tiles"].
-        inplace : bool, optional
-            Whether to modify the existing track in place or return
-            a new track with the data applied (default: `False`).
-
-        Returns
-        -------
-        track : A track with local data configured.
-        """
-        min_pos = tsinfo.get("min_pos", [])
-        max_pos = tsinfo.get("max_pos", [])
-
-        if len(min_pos) != len(max_pos):
-            raise ValueError("min_pos and max_pos must have equal lengths")
-
-        if len(min_pos) == 2:
-            tile_key = "x.0.0.0"
-        elif len(min_pos) == 1:
-            tile_key = "x.0.0"
-        else:
-            raise ValueError("min_pos must be a one or two element array")
-
-        track = self if inplace else utils.copy_unique(self)
-        track.data = {
-            "type": "local-tiles",
-            "tilesetInfo": {"x": tsinfo},
-            "tiles": {tile_key: data},
-        }
-        return track
-
-
 ## Extend higlass-schema classes
 
 
-class EnumTrack(hgs.EnumTrack, _LocalDataMixin, _OptionsMixin, _PropertiesMixin):
+class EnumTrack(hgs.EnumTrack, _OptionsMixin, _PropertiesMixin):
     """Represents a generic track."""
 
     ...
 
 
-class HeatmapTrack(hgs.HeatmapTrack, _LocalDataMixin, _OptionsMixin, _PropertiesMixin):
+class HeatmapTrack(hgs.HeatmapTrack, _OptionsMixin, _PropertiesMixin):
     """Represets a specialized heatmap track."""
 
     ...
@@ -196,7 +151,7 @@ class CombinedTrack(hgs.CombinedTrack, _OptionsMixin, _PropertiesMixin):
     ...
 
 
-class PluginTrack(hgs.BaseTrack, _OptionsMixin, _PropertiesMixin, _LocalDataMixin):
+class PluginTrack(hgs.BaseTrack, _OptionsMixin, _PropertiesMixin):
     """Represents an unknown plugin track."""
 
     plugin_url: ClassVar[str]

src/higlass/tilesets.py

@@ -11,6 +11,7 @@
 from higlass._utils import TrackType, datatype_default_track
 
 __all__ = [
+    "LocalDataTileset",
     "Tileset",
     "bed2ddb",
     "bigwig",
@@ -71,6 +72,59 @@ def remote(
     return RemoteTileset(uid, server, name)
 
 
+@dataclass
+class LocalDataTileset:
+    """A tileset that serves data locally without a server.
+
+    Parameters
+    ----------
+    tsinfo : dict
+        Tileset info dict (must include ``min_pos`` and ``max_pos``).
+    data : list
+        Tile data for the tileset.
+    """
+
+    tsinfo: dict
+    data: list
+
+    def __post_init__(self):
+        min_pos = self.tsinfo.get("min_pos", [])
+        max_pos = self.tsinfo.get("max_pos", [])
+
+        if len(min_pos) != len(max_pos):
+            raise ValueError("min_pos and max_pos must have equal lengths")
+
+        if len(min_pos) == 2:
+            self._tile_key = "x.0.0.0"
+        elif len(min_pos) == 1:
+            self._tile_key = "x.0.0"
+        else:
+            raise ValueError("min_pos must be a one or two element array")
+
+    def track(self, type_: TrackType, **kwargs) -> higlass.api.Track:
+        """Create a HiGlass track with local data embedded.
+
+        Parameters
+        ----------
+        type_ : TrackType
+            The track type to create.
+        **kwargs : dict
+            Additional top-level track properties.
+
+        Returns
+        -------
+        higlass.api.Track
+            A track with the ``data`` section populated for local-tiles.
+        """
+        trk = higlass.api.track(type_=type_, **kwargs)
+        trk.data = {
+            "type": "local-tiles",
+            "tilesetInfo": {"x": self.tsinfo},
+            "tiles": {self._tile_key: self.data},
+        }
+        return trk
+
+
 class Tileset(abc.ABC):
     """Base class for defining custom tilesets in `higlass`.
 

test/test_api.py

@@ -209,31 +209,26 @@ def test_options_mixin():
     assert track.options and track.options["foo"] == "bar"
 
 
-def test_local_data_mixin():
-    track = hg.track("heatmap")
+def test_local_data_tileset():
     tsinfo = {"min_pos": [0, 0], "max_pos": [100, 100]}
     data = [{"x": 1, "y": 2}]
 
-    other = track.local_data(tsinfo, data)
-    assert track.uid != other.uid
-    assert track.data is None
+    tileset = hg.LocalDataTileset(tsinfo, data)
+    other = tileset.track("heatmap")
     assert other.data.type == "local-tiles"
     assert other.data.tilesetInfo["x"] == tsinfo
     assert other.data.tiles["x.0.0.0"] == data
 
-    track2 = hg.track("heatmap")
     tsinfo_1d = {"min_pos": [0], "max_pos": [100]}
-    other2 = track2.local_data(tsinfo_1d, data, inplace=True)
-    assert track2 is other2
-    assert track2.data.tiles["x.0.0"] == data
+    tileset_1d = hg.LocalDataTileset(tsinfo_1d, data)
+    other_1d = tileset_1d.track("heatmap")
+    assert other_1d.data.tiles["x.0.0"] == data
 
     with pytest.raises(ValueError, match="min_pos and max_pos must have equal lengths"):
-        hg.track("heatmap").local_data({"min_pos": [0], "max_pos": [0, 0]}, data)
+        hg.LocalDataTileset({"min_pos": [0], "max_pos": [0, 0]}, data)
 
     with pytest.raises(ValueError, match="min_pos must be a one or two element array"):
-        hg.track("heatmap").local_data(
-            {"min_pos": [0, 0, 0], "max_pos": [0, 0, 0]}, data
-        )
+        hg.LocalDataTileset({"min_pos": [0, 0, 0], "max_pos": [0, 0, 0]}, data)
 
 
 def test_plugin_track():