starplot 0.15.5__py2.py3-none-any.whl → 0.15.7__py2.py3-none-any.whl

starplot/models/star.py

@@ -1,11 +1,11 @@
 import math
-from typing import Optional, Union, Iterator
+from typing import Optional, Union, Iterator, Any
 
 import numpy as np
-from shapely import Point
 from ibis import _
+from pydantic import field_validator
 
-from starplot.models.base import SkyObject
+from starplot.models.base import SkyObject, ShapelyPoint
 from starplot.data.stars import StarCatalog, load as _load_stars
 
 
@@ -38,38 +38,20 @@ class Star(SkyObject):
     flamsteed: Optional[int] = None
     """Flamsteed number, if available"""
 
-    geometry: Point = None
+    geometry: ShapelyPoint = None
     """Shapely Point of the star's position. Right ascension coordinates are in degrees (0...360)."""
 
-    def __init__(
-        self,
-        ra: float,
-        dec: float,
-        magnitude: float,
-        bv: float = None,
-        hip: int = None,
-        name: str = None,
-        tyc: str = None,
-        ccdm: str = None,
-        geometry: Point = None,
-        constellation_id: str = None,
-        bayer: str = None,
-        flamsteed: int = None,
-    ) -> None:
-        super().__init__(ra, dec, constellation_id)
-        self.magnitude = magnitude
-        self.bv = bv
-        self.hip = hip if hip is not None and np.isfinite(hip) else None
-        self.name = name
-        self.tyc = tyc
-        self.ccdm = ccdm
-        self.geometry = geometry
-
-        if bayer:
-            self.bayer = bayer
-
-        if flamsteed and not math.isnan(flamsteed):
-            self.flamsteed = int(flamsteed)
+    @field_validator("flamsteed", "hip", mode="before")
+    @classmethod
+    def nan(cls, value: int) -> int:
+        if not value or math.isnan(value):
+            return None
+
+        return int(value)
+
+    def model_post_init(self, context: Any) -> None:
+        self.bayer = self.bayer or None
+        self.hip = self.hip if self.hip is not None and np.isfinite(self.hip) else None
 
     def __repr__(self) -> str:
         return f"Star(hip={self.hip}, tyc={self.tyc}, magnitude={self.magnitude}, ra={self.ra}, dec={self.dec})"
@@ -83,7 +65,7 @@ class Star(SkyObject):
 
     @classmethod
     def get(
-        cls, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, **kwargs
+        cls, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, sql: str = None, **kwargs
     ) -> Union["Star", None]:
         """
         Get a Star, by matching its attributes as specified in `**kwargs`
@@ -94,6 +76,7 @@ class Star(SkyObject):
 
         Args:
             catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [`StarCatalog`](/reference-data/#starplot.data.stars.StarCatalog) for details
+            sql: SQL query for selecting star (table name is "_")
             **kwargs: Attributes on the star you want to match
 
         Raises: `ValueError` if more than one star is matched
@@ -109,6 +92,7 @@ class Star(SkyObject):
         df = _load_stars(
             catalog=catalog,
             filters=filters,
+            sql=sql,
         ).to_pandas()
 
         results = [from_tuple(s) for s in df.itertuples()]
@@ -125,13 +109,17 @@ class Star(SkyObject):
 
     @classmethod
     def find(
-        cls, where: list, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11
+        cls,
+        where: list = None,
+        sql: str = None,
+        catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11,
     ) -> list["Star"]:
         """
         Find Stars
 
         Args:
             where: A list of expressions that determine which stars to find. See [Selecting Objects](/reference-selecting-objects/) for details.
+            sql: SQL query for selecting stars (table name is "_")
             catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [`StarCatalog`](/reference-data/#starplot.data.stars.StarCatalog) for details
 
         Returns:
@@ -141,6 +129,7 @@ class Star(SkyObject):
         df = _load_stars(
             catalog=catalog,
             filters=where,
+            sql=sql,
         ).to_pandas()
 
         return [from_tuple(s) for s in df.itertuples()]
@@ -157,10 +146,10 @@ def from_tuple(star: tuple) -> Star:
         ccdm=getattr(star, "ccdm", None),
         name=getattr(star, "name", None),
         geometry=star.geometry,
-        constellation_id=getattr(star, "constellation", None),
         bayer=getattr(star, "bayer", None),
         flamsteed=getattr(star, "flamsteed", None),
     )
+    s._constellation_id = getattr(star, "constellation", None)
     s._row_id = getattr(star, "rowid", None)
 
     return s

starplot/models/sun.py

@@ -2,10 +2,9 @@ from datetime import datetime
 
 import numpy as np
 from skyfield.api import Angle, wgs84
-from shapely import Polygon
 
 from starplot.data import load
-from starplot.models.base import SkyObject
+from starplot.models.base import SkyObject, ShapelyPolygon
 from starplot.geometry import circle
 from starplot.utils import dt_or_now
 
@@ -22,24 +21,9 @@ class Sun(SkyObject):
     apparent_size: float
     """Apparent size (degrees)"""
 
-    geometry: Polygon = None
+    geometry: ShapelyPolygon = None
     """Shapely Polygon of the Sun's extent. Right ascension coordinates are in degrees (0...360)."""
 
-    def __init__(
-        self,
-        ra: float,
-        dec: float,
-        name: str,
-        dt: datetime,
-        apparent_size: float,
-        geometry: Polygon = None,
-    ) -> None:
-        super().__init__(ra, dec)
-        self.name = name
-        self.dt = dt
-        self.apparent_size = apparent_size
-        self.geometry = geometry
-
     @classmethod
     def get(
         cls,

starplot/optic.py

@@ -220,6 +220,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         legend_label: str = "Star",
         bayer_labels: bool = False,
         flamsteed_labels: bool = False,
+        sql: str = None,
         *args,
         **kwargs,
     ):
@@ -229,7 +230,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
         Args:
             where: A list of expressions that determine which stars to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
             where_labels: A list of expressions that determine which stars are labeled on the plot. See [Selecting Objects](/reference-selecting-objects/) for details.
-            catalog: The catalog of stars to use
+            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [star catalogs](/data/star-catalogs/) for details
             style: If `None`, then the plot's style for stars will be used
             rasterize: If True, then the stars will be rasterized when plotted, which can speed up exporting to SVG and reduce the file size but with a loss of image quality
             size_fn: Callable for calculating the marker size of each star. If `None`, then the marker style's size will be used.
@@ -239,6 +240,7 @@ class OpticPlot(BasePlot, ExtentMaskMixin, StarPlotterMixin, DsoPlotterMixin):
             legend_label: Label for stars in the legend. If `None`, then they will not be in the legend.
             bayer_labels: If True, then Bayer labels for stars will be plotted.
             flamsteed_labels: If True, then Flamsteed number labels for stars will be plotted.
+            sql: SQL query for selecting stars (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
         """
         optic_star_multiplier = self.FIELD_OF_VIEW_MAX / self.optic.true_fov
         size_fn_mx = None

starplot/optics.py

@@ -3,18 +3,15 @@ import math
 from abc import ABC, abstractmethod
 
 import pyproj
-
 from matplotlib import patches
+from pydantic import BaseModel, computed_field
 
 from starplot.utils import in_circle
 
 
-class Optic(ABC):
+class Optic(BaseModel, ABC):
     """Abstract class for defining Optics."""
 
-    def __init__(self) -> "Optic":
-        pass
-
     def __str__(self):
         return "Optic"
 
@@ -70,18 +67,34 @@ class Scope(Optic):
         Scope: A new instance of a Scope optic
     """
 
-    def __init__(
-        self, focal_length: float, eyepiece_focal_length: float, eyepiece_fov: float
-    ) -> "Scope":
-        self.focal_length = focal_length
-        self.eyepiece_focal_length = eyepiece_focal_length
-        self.eyepiece_fov = eyepiece_fov
-        self.magnification = self.focal_length / self.eyepiece_focal_length
-        self.true_fov = self.eyepiece_fov / self.magnification
-        self.radius = self._compute_radius(self.true_fov / 2)
+    focal_length: float
+    """Focal length (mm) of the telescope"""
+
+    eyepiece_focal_length: float
+    """Focal length (mm) of the eyepiece"""
+
+    eyepiece_fov: float
+    """Field of view (degrees) of the eyepiece"""
+
+    @computed_field
+    @property
+    def magnification(self) -> float:
+        """Magnification calculated from the telescope's focal length and eyepiece focal length"""
+        return self.focal_length / self.eyepiece_focal_length
+
+    @computed_field
+    @property
+    def true_fov(self) -> float:
+        """True field of view of telescope"""
+        return self.eyepiece_fov / self.magnification
+
+    @computed_field
+    @property
+    def radius(self) -> float:
+        return self._compute_radius(self.true_fov / 2)
 
     def __str__(self):
-        return f"{self.focal_length}mm w/ {self.eyepiece_focal_length}mm ({self.magnification:.0f}x) @  {self.eyepiece_fov:.0f}\N{DEGREE SIGN} = {self.true_fov:.2f}\N{DEGREE SIGN} TFOV"
+        return f"{self.focal_length:.0f}mm w/ {self.eyepiece_focal_length:.0f}mm ({self.magnification:.0f}x) @  {self.eyepiece_fov:.0f}\N{DEGREE SIGN} = {self.true_fov:.2f}\N{DEGREE SIGN} TFOV"
 
     @property
     def xlim(self):
@@ -172,14 +185,25 @@ class Binoculars(Optic):
 
     """
 
-    def __init__(self, magnification: float, fov: float) -> "Binoculars":
-        self.magnification = magnification
-        self.apparent_fov = fov
-        self.true_fov = self.apparent_fov / self.magnification
-        self.radius = self._compute_radius(self.true_fov / 2)
+    magnification: float
+    """Magnification of the binoculars"""
+
+    fov: float
+    """Apparent field of view of the binoculars"""
+
+    @computed_field
+    @property
+    def true_fov(self) -> float:
+        """True field of view of binoculars"""
+        return self.fov / self.magnification
+
+    @computed_field
+    @property
+    def radius(self) -> float:
+        return self._compute_radius(self.true_fov / 2)
 
     def __str__(self):
-        return f"{self.magnification}x @ {self.apparent_fov}\N{DEGREE SIGN} = {self.true_fov}\N{DEGREE SIGN}"
+        return f"{self.magnification:.0f}x @ {self.fov:.0f}\N{DEGREE SIGN} = {self.true_fov}\N{DEGREE SIGN}"
 
     @property
     def xlim(self):
@@ -225,39 +249,56 @@ class Camera(Optic):
         sensor_height: Height of camera sensor (mm)
         sensor_width: Width of camera sensor (mm)
         lens_focal_length: Focal length of camera lens (mm)
-        rotation: Angle (degrees) to rotate camera
+        rotation: Angle (degrees) to rotate camera, defaults to 0
 
     Returns:
         Camera: A new instance of a Camera optic
 
     """
 
-    def __init__(
-        self,
-        sensor_height: float,
-        sensor_width: float,
-        lens_focal_length: float,
-        rotation: float = 0,
-    ) -> "Camera":
-        self.sensor_height = sensor_height
-        self.sensor_width = sensor_width
-        self.lens_focal_length = lens_focal_length
-
-        self.true_fov_x = 2 * math.degrees(
+    sensor_height: float
+    """Height (mm) of camera's sensor"""
+
+    sensor_width: float
+    """Width (mm) of camera's sensor"""
+
+    lens_focal_length: float
+    """Focal length (mm) of the camera's lens"""
+
+    rotation: float = 0
+    """Angle (degrees) to rotate the camera"""
+
+    @computed_field
+    @property
+    def true_fov_x(self) -> float:
+        return 2 * math.degrees(
             math.atan(self.sensor_width / (2 * self.lens_focal_length))
         )
-        self.true_fov_y = 2 * math.degrees(
+
+    @computed_field
+    @property
+    def true_fov_y(self) -> float:
+        return 2 * math.degrees(
             math.atan(self.sensor_height / (2 * self.lens_focal_length))
         )
-        self.true_fov = max(self.true_fov_x, self.true_fov_y)
 
-        self.radius_x = self._compute_radius(self.true_fov_x / 2)
-        self.radius_y = self._compute_radius(self.true_fov_y / 2)
+    @computed_field
+    @property
+    def true_fov(self) -> float:
+        return max(self.true_fov_x, self.true_fov_y)
+
+    @computed_field
+    @property
+    def radius_x(self) -> float:
+        return self._compute_radius(self.true_fov_x / 2)
 
-        self.rotation = rotation
+    @computed_field
+    @property
+    def radius_y(self) -> float:
+        return self._compute_radius(self.true_fov_y / 2)
 
     def __str__(self):
-        return f"{self.sensor_width}x{self.sensor_height} w/ {self.lens_focal_length}mm lens = {self.true_fov_x:.2f}\N{DEGREE SIGN} x {self.true_fov_y:.2f}\N{DEGREE SIGN}"
+        return f"{self.sensor_width}x{self.sensor_height} w/ {self.lens_focal_length:.0f}mm lens = {self.true_fov_x:.2f}\N{DEGREE SIGN} x {self.true_fov_y:.2f}\N{DEGREE SIGN}"
 
     @property
     def xlim(self):

starplot/plotters/constellations.py

@@ -12,9 +12,9 @@ from starplot.data import constellations as condata, constellation_lines as conl
 from starplot.data.stars import load as load_stars, StarCatalog
 from starplot.data.constellations import (
     CONSTELLATIONS_FULL_NAMES,
-    CONSTELLATION_HIP_IDS,
 )
 from starplot.data.constellation_stars import CONSTELLATION_HIPS
+from starplot.models import Star
 from starplot.models.constellation import from_tuple as constellation_from_tuple
 from starplot.projections import Projection
 from starplot.profile import profile
@@ -65,6 +65,7 @@ class ConstellationPlotterMixin:
         self,
         style: LineStyle = None,
         where: list = None,
+        sql: str = None,
     ):
         """Plots the constellation lines **only**. To plot constellation borders and/or labels, see separate functions for them.
 
@@ -73,6 +74,7 @@ class ConstellationPlotterMixin:
         Args:
             style: Styling of the constellations. If None, then the plot's style (specified when creating the plot) will be used
             where: A list of expressions that determine which constellations to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
+            sql: SQL query for selecting constellations (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
         """
         self.logger.debug("Plotting constellation lines...")
 
@@ -80,7 +82,7 @@ class ConstellationPlotterMixin:
         ctr = 0
 
         extent = self._extent_mask()
-        results = condata.load(extent=extent, filters=where)
+        results = condata.load(extent=extent, filters=where, sql=sql)
         constellations_df = results.to_pandas()
 
         if constellations_df.empty:
@@ -262,11 +264,17 @@ class ConstellationPlotterMixin:
         self.ax.add_collection(line_collection)
 
     def _constellation_labels_auto(self, style, labels, settings):
+        hips = []
+        for c in self.objects.constellations:
+            hips.extend(c.star_hip_ids)
+
+        all_constellation_stars = Star.find(where=[_.hip.isin(hips)])
+
         for constellation in self.objects.constellations:
             constellation_line_stars = [
                 s
-                for s in self.objects.stars
-                if s.hip in CONSTELLATION_HIP_IDS[constellation.iau_id]
+                for s in all_constellation_stars
+                if s.hip in constellation.star_hip_ids
             ]
             if not constellation_line_stars:
                 continue
@@ -302,10 +310,11 @@ class ConstellationPlotterMixin:
             text = labels.get(con.lower())
             self.text(
                 text,
-                ra,
+                ra * 15,
                 dec,
                 style,
                 hide_on_collision=self.hide_colliding_labels,
+                remove_on_constellation_collision=False,
                 gid="constellations-label-name",
             )
 
@@ -319,7 +328,7 @@ class ConstellationPlotterMixin:
         auto_adjust_settings: dict = DEFAULT_AUTO_ADJUST_SETTINGS,
     ):
         """
-        Plots constellation labels.
+        Plots constellation labels for all constellations that have been plotted. This means you must plot the constellations before plotting their labels.
 
         It's good to plot these last because they're area-based labels (vs point-based, like for star names), and area-based labels have more freedom to move around. If you plot area-based labels first, then it would limit the available space for point-based labels.
 
@@ -328,10 +337,6 @@ class ConstellationPlotterMixin:
             labels: A dictionary where the keys are each constellation's 3-letter IAU abbreviation, and the values are how the constellation will be labeled on the plot.
             auto_adjust: If True (the default), then labels will be automatically adjusted to avoid collisions with other labels and stars **Important: you must plot stars and constellations first for this to work**. This uses a fairly simple method: for each constellation it finds the centroid of all plotted constellation stars with lines and then generates random points in the constellation boundary starting at the centroid and then progressively increasing the distance from the centroid.
             auto_adjust_settings: Optional settings for the auto adjustment algorithm.
-
-        TODO:
-            make this work without plotting constellations first
-
         """
 
         if auto_adjust:

starplot/plotters/dsos.py

@@ -44,7 +44,7 @@ class DsoPlotterMixin:
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
         where = kwargs.pop("where", [])
-        where.append(_.type == DsoType.OPEN_CLUSTER)
+        where.append(_.type == DsoType.OPEN_CLUSTER.value)
         self.dsos(where=where, **kwargs)
 
     def globular_clusters(self, **kwargs):
@@ -54,7 +54,7 @@ class DsoPlotterMixin:
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
         where = kwargs.pop("where", [])
-        where.append(_.type == DsoType.GLOBULAR_CLUSTER)
+        where.append(_.type == DsoType.GLOBULAR_CLUSTER.value)
         self.dsos(where=where, **kwargs)
 
     def galaxies(self, **kwargs):
@@ -68,9 +68,9 @@ class DsoPlotterMixin:
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
         galaxy_types = [
-            DsoType.GALAXY,
-            DsoType.GALAXY_PAIR,
-            DsoType.GALAXY_TRIPLET,
+            DsoType.GALAXY.value,
+            DsoType.GALAXY_PAIR.value,
+            DsoType.GALAXY_TRIPLET.value,
         ]
         where = kwargs.pop("where", [])
         where.append(_.type.isin(galaxy_types))
@@ -85,15 +85,19 @@ class DsoPlotterMixin:
         - Emission Nebula
         - Star Cluster Nebula
         - Reflection Nebula
+        - HII Ionized Regions
+
+        * Note that this does NOT plot dark nebulae
 
         This is just a small wrapper around the `dsos()` function, so any `kwargs` will be passed through.
         """
         nebula_types = [
-            DsoType.NEBULA,
-            DsoType.PLANETARY_NEBULA,
-            DsoType.EMISSION_NEBULA,
-            DsoType.STAR_CLUSTER_NEBULA,
-            DsoType.REFLECTION_NEBULA,
+            DsoType.NEBULA.value,
+            DsoType.PLANETARY_NEBULA.value,
+            DsoType.EMISSION_NEBULA.value,
+            DsoType.STAR_CLUSTER_NEBULA.value,
+            DsoType.REFLECTION_NEBULA.value,
+            DsoType.HII_IONIZED_REGION.value,
         ]
         where = kwargs.pop("where", [])
         where.append(_.type.isin(nebula_types))
@@ -109,6 +113,8 @@ class DsoPlotterMixin:
         legend_labels: Mapping[DsoType, str] = DSO_LEGEND_LABELS,
         alpha_fn: Callable[[DSO], float] = None,
         label_fn: Callable[[DSO], str] = None,
+        sql: str = None,
+        sql_labels: str = None,
     ):
         """
         Plots Deep Sky Objects (DSOs), from OpenNGC
@@ -121,6 +127,8 @@ class DsoPlotterMixin:
             legend_labels: A dictionary that maps a `DsoType` to the legend label that'll be plotted for that type of DSO. If you want to hide all DSO legend labels, then set this arg to `None`.
             alpha_fn: Callable for calculating the alpha value (aka "opacity") of each DSO. If `None`, then the marker style's alpha will be used.
             label_fn: Callable for determining the label of each DSO. If `None`, then the names in the `labels` kwarg will be used.
+            sql: SQL query for selecting DSOs (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
+            sql_labels: SQL query for selecting DSOs that will be labeled (table name is `_`). Applied _after_ any filters in the `where_labels` kwarg.
         """
 
         # TODO: add kwarg styles
@@ -139,12 +147,19 @@ class DsoPlotterMixin:
             legend_labels = {**DSO_LEGEND_LABELS, **legend_labels}
 
         extent = self._extent_mask()
-        dso_results = load(extent=extent, filters=where)
+        dso_results = load(extent=extent, filters=where, sql=sql)
 
         dso_results_labeled = dso_results
         for f in where_labels:
             dso_results_labeled = dso_results_labeled.filter(f)
 
+        if sql_labels:
+            result = (
+                dso_results_labeled.alias("_").sql(sql_labels).select("sk").execute()
+            )
+            skids = result["sk"].to_list()
+            dso_results_labeled = dso_results_labeled.filter(_.sk.isin(skids))
+
         label_row_ids = dso_results_labeled.to_pandas()["rowid"].tolist()
 
         results_df = dso_results.to_pandas()

starplot/plotters/stars.py

@@ -2,6 +2,7 @@ from typing import Callable, Mapping
 
 import rtree
 import numpy as np
+from ibis import _ as ibis_table
 from skyfield.api import Star as SkyfieldStar, wgs84
 
 from starplot import callables
@@ -13,13 +14,14 @@ from starplot.profile import profile
 
 
 class StarPlotterMixin:
-    def _load_stars(self, catalog, filters=None):
+    def _load_stars(self, catalog, filters=None, sql=None):
         extent = self._extent_mask()
 
         return stars.load(
             extent=extent,
             catalog=catalog,
             filters=filters,
+            sql=sql,
         )
 
     def _scatter_stars(self, ras, decs, sizes, alphas, colors, style=None, **kwargs):
@@ -165,6 +167,8 @@ class StarPlotterMixin:
         legend_label: str = "Star",
         bayer_labels: bool = False,
         flamsteed_labels: bool = False,
+        sql: str = None,
+        sql_labels: str = None,
         *args,
         **kwargs,
     ):
@@ -180,7 +184,7 @@ class StarPlotterMixin:
         Args:
             where: A list of expressions that determine which stars to plot. See [Selecting Objects](/reference-selecting-objects/) for details.
             where_labels: A list of expressions that determine which stars are labeled on the plot (this includes all labels: name, Bayer, and Flamsteed). If you want to hide **all** labels, then set this arg to `[False]`. See [Selecting Objects](/reference-selecting-objects/) for details.
-            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [`StarCatalog`](/reference-data/#starplot.data.stars.StarCatalog) for details
+            catalog: The catalog of stars to use: "big-sky-mag11", or "big-sky" -- see [star catalogs](/data/star-catalogs/) for details
             style: If `None`, then the plot's style for stars will be used
             size_fn: Callable for calculating the marker size of each star. If `None`, then the marker style's size will be used.
             alpha_fn: Callable for calculating the alpha value (aka "opacity") of each star. If `None`, then the marker style's alpha will be used.
@@ -190,6 +194,8 @@ class StarPlotterMixin:
             legend_label: Label for stars in the legend. If `None`, then they will not be in the legend.
             bayer_labels: If True, then Bayer labels for stars will be plotted.
             flamsteed_labels: If True, then Flamsteed number labels for stars will be plotted.
+            sql: SQL query for selecting stars (table name is `_`). This query will be applied _after_ any filters in the `where` kwarg.
+            sql_labels: SQL query for selecting stars that will be labeled (table name is `_`). Applied _after_ any filters in the `where_labels` kwarg.
         """
 
         # fallback to style if callables are None
@@ -205,12 +211,21 @@ class StarPlotterMixin:
         stars_to_index = []
         labels = labels or {}
 
-        star_results = self._load_stars(catalog, filters=where)
+        star_results = self._load_stars(catalog, filters=where, sql=sql)
 
         star_results_labeled = star_results
         for f in where_labels:
             star_results_labeled = star_results_labeled.filter(f)
 
+        if sql_labels:
+            result = (
+                star_results_labeled.alias("_").sql(sql_labels).select("sk").execute()
+            )
+            skids = result["sk"].to_list()
+            star_results_labeled = star_results_labeled.filter(
+                ibis_table.sk.isin(skids)
+            )
+
         label_row_ids = star_results_labeled.to_pandas()["rowid"].tolist()
 
         stars_df = star_results.to_pandas()

{starplot-0.15.5.dist-info → starplot-0.15.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: starplot
-Version: 0.15.5
+Version: 0.15.7
 Summary: Star charts and maps of the sky
 Keywords: astronomy,stars,charts,maps,constellations,sky,plotting
 Author-email: Steve Berardi <hello@steveberardi.com>
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
 Requires-Dist: matplotlib >= 3.8.0
 Requires-Dist: numpy >= 1.26.2
 Requires-Dist: pandas >= 1.4.0