starplot 0.15.6__py2.py3-none-any.whl → 0.15.8__py2.py3-none-any.whl

starplot/__init__.py

@@ -1,6 +1,6 @@
 """Star charts and maps of the sky"""
 
-__version__ = "0.15.6"
+__version__ = "0.15.8"
 
 from .base import BasePlot  # noqa: F401
 from .map import MapPlot, Projection  # noqa: F401

starplot/data/constellations.py

@@ -1,3 +1,5 @@
+from functools import cache
+
 import ibis
 from ibis import _
 
@@ -669,23 +671,35 @@ CONSTELLATION_HIP_IDS = {
 }
 
 
-def load(extent=None, filters=None):
-    filters = filters or []
+@cache
+def table():
     con = db.connect()
     c = con.table("constellations")
-    c = c.mutate(
+
+    return c.mutate(
         ra=_.center_ra,
         dec=_.center_dec,
         constellation_id=_.iau_id,
-        rowid=ibis.row_number(),
         boundary=_.geometry,
+        rowid=ibis.row_number(),
+        sk=ibis.row_number(),
     )
 
+
+def load(extent=None, filters=None, sql=None):
+    filters = filters or []
+    c = table()
+
     if extent:
         filters.append(_.geometry.intersects(extent))
 
     if filters:
-        return c.filter(*filters)
+        c = c.filter(*filters)
+
+    if sql:
+        result = c.alias("_").sql(sql).select("sk").execute()
+        skids = result["sk"].to_list()
+        c = c.filter(_.sk.isin(skids))
 
     return c
 

starplot/data/dsos.py

@@ -1,3 +1,5 @@
+from functools import cache
+
 import ibis
 from ibis import _
 
@@ -25,26 +27,37 @@ class DsoLabelMaker(dict):
 DSO_LABELS_DEFAULT = DsoLabelMaker()
 
 
-def load(extent=None, filters=None):
-    filters = filters or []
+@cache
+def table():
     con = db.connect()
     dsos = con.table("deep_sky_objects")
 
-    dsos = dsos.mutate(
+    return dsos.mutate(
         ra=_.ra_degrees,
         dec=_.dec_degrees,
         constellation_id=_.constellation,
         magnitude=ibis.coalesce(_.mag_v, _.mag_b, None),
         size=_.size_deg2,
         rowid=ibis.row_number(),
+        sk=ibis.row_number(),
     )
 
+
+def load(extent=None, filters=None, sql=None):
+    filters = filters or []
+    dsos = table()
+
     if extent:
         dsos = dsos.filter(_.geometry.intersects(extent))
 
     filters.extend([_.ra_degrees.notnull() & _.dec_degrees.notnull()])
 
     if filters:
-        return dsos.filter(*filters)
+        dsos = dsos.filter(*filters)
+
+    if sql:
+        result = dsos.alias("_").sql(sql).select("sk").execute()
+        skids = result["sk"].to_list()
+        dsos = dsos.filter(_.sk.isin(skids))
 
     return dsos

starplot/data/stars.py

@@ -459,7 +459,7 @@ class StarCatalog:
 
 
 @cache
-def read_catalog(catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, table_name="stars"):
+def table(catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, table_name="stars"):
     con = db.connect()
 
     if catalog == StarCatalog.BIG_SKY_MAG11:
@@ -481,6 +481,7 @@ def read_catalog(catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, table_name="s
         # stars parquet does not have geometry field
         geometry=_.ra_degrees.point(_.dec_degrees),
         rowid=ibis.row_number(),
+        sk=ibis.row_number(),
     )
 
     stars = stars.join(
@@ -495,14 +496,24 @@ def read_catalog(catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, table_name="s
     return stars
 
 
-def load(extent=None, catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11, filters=None):
+def load(
+    extent=None,
+    catalog: StarCatalog = StarCatalog.BIG_SKY_MAG11,
+    filters=None,
+    sql=None,
+):
     filters = filters or []
-    stars = read_catalog(catalog)
+    stars = table(catalog)
 
     if extent:
         stars = stars.filter(stars.geometry.intersects(extent))
 
     if filters:
-        return stars.filter(*filters)
+        stars = stars.filter(*filters)
+
+    if sql:
+        result = stars.alias("_").sql(sql).select("sk").execute()
+        skids = result["sk"].to_list()
+        stars = stars.filter(_.sk.isin(skids))
 
     return stars

starplot/models/base.py

@@ -1,40 +1,86 @@
+import json
+
 from functools import cache
 from typing import Optional
 
+from shapely import to_geojson, from_geojson, Geometry
+from shapely.geometry import Polygon, MultiPolygon, Point
+
+from pydantic_core import core_schema
+
+from pydantic import (
+    BaseModel,
+    computed_field,
+)
 from skyfield.api import position_of_radec, load_constellation_map
 
 from starplot.mixins import CreateMapMixin, CreateOpticMixin
 
 
+class ShapelyPydantic:
+    @classmethod
+    def validate(cls, field_value, info):
+        return field_value.is_valid
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source, handler) -> core_schema.CoreSchema:
+        def validate_from_geojson(value: dict) -> Geometry:
+            return from_geojson(json.loads(value))
+
+        from_dict_schema = core_schema.chain_schema(
+            [
+                core_schema.dict_schema(),
+                core_schema.no_info_plain_validator_function(validate_from_geojson),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=from_dict_schema,
+            python_schema=core_schema.union_schema(
+                [
+                    core_schema.is_instance_schema(Geometry),
+                    from_dict_schema,
+                ]
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda instance: json.loads(to_geojson(instance))
+            ),
+        )
+
+
+class ShapelyPolygon(ShapelyPydantic, Polygon):
+    pass
+
+
+class ShapelyMultiPolygon(ShapelyPydantic, MultiPolygon):
+    pass
+
+
+class ShapelyPoint(ShapelyPydantic, Point):
+    pass
+
+
 @cache
 def constellation_at():
     return load_constellation_map()
 
 
-class SkyObject(CreateMapMixin, CreateOpticMixin):
+class SkyObject(BaseModel, CreateMapMixin, CreateOpticMixin):
     """
     Basic sky object model.
     """
 
     ra: float
-    """Right Ascension, in degrees (0...360)"""
+    """Right Ascension, in degrees (0 to 360)"""
 
     dec: float
-    """Declination, in degrees (-90...90)"""
-
-    _constellation_id = None
-
-    constellation_id: Optional[str] = None
-    """Identifier of the constellation that contains this object. The ID is the three-letter (all lowercase) abbreviation from the International Astronomical Union (IAU)."""
+    """Declination, in degrees (-90 to 90)"""
 
-    def __init__(self, ra: float, dec: float, constellation_id: str = None) -> None:
-        self.ra = ra
-        self.dec = dec
-        if constellation_id:
-            self._constellation_id = constellation_id
+    _constellation_id: Optional[str] = None
 
+    @computed_field
     @property
-    def constellation_id(self):
+    def constellation_id(self) -> str | None:
         """Identifier of the constellation that contains this object. The ID is the three-letter (all lowercase) abbreviation from the International Astronomical Union (IAU)."""
         if not self._constellation_id:
             pos = position_of_radec(self.ra, self.dec)

starplot/models/constellation.py

@@ -1,9 +1,8 @@
-from typing import Union, Iterator
+from typing import Iterator
 
 from ibis import _
-from shapely import Polygon, MultiPolygon
 
-from starplot.models.base import SkyObject
+from starplot.models.base import SkyObject, ShapelyPolygon, ShapelyMultiPolygon
 from starplot.data import constellations
 
 
@@ -21,29 +20,14 @@ class Constellation(SkyObject):
     """
 
     name: str = None
-    """Name"""
+    """Name of constellation"""
 
     star_hip_ids: list[int] = None
     """List of HIP ids for stars that are part of the _lines_ for this constellation."""
 
-    boundary: Union[Polygon, MultiPolygon] = None
+    boundary: ShapelyPolygon | ShapelyMultiPolygon = None
     """Shapely Polygon of the constellation's boundary. Right ascension coordinates are in degrees (0...360)."""
 
-    def __init__(
-        self,
-        ra: float,
-        dec: float,
-        iau_id: str,
-        name: str = None,
-        star_hip_ids: list[int] = None,
-        boundary: Polygon = None,
-    ) -> None:
-        super().__init__(ra, dec, constellation_id=iau_id.lower())
-        self.iau_id = iau_id.lower()
-        self.name = name
-        self.star_hip_ids = star_hip_ids
-        self.boundary = boundary
-
     def __repr__(self) -> str:
         return f"Constellation(iau_id={self.iau_id}, name={self.name}, ra={self.ra}, dec={self.dec})"
 
@@ -55,7 +39,7 @@ class Constellation(SkyObject):
             yield from_tuple(c)
 
     @classmethod
-    def get(cls, **kwargs) -> "Constellation":
+    def get(cls, sql: str = None, **kwargs) -> "Constellation":
         """
         Get a Constellation, by matching its attributes.
 
@@ -64,6 +48,7 @@ class Constellation(SkyObject):
             hercules = Constellation.get(name="Hercules")
 
         Args:
+            sql: SQL query for selecting constellation (table name is "_")
             **kwargs: Attributes on the constellation you want to match
 
         Raises: `ValueError` if more than one constellation is matched
@@ -73,7 +58,7 @@ class Constellation(SkyObject):
         for k, v in kwargs.items():
             filters.append(getattr(_, k) == v)
 
-        df = constellations.load(filters=filters).to_pandas()
+        df = constellations.load(filters=filters, sql=sql).to_pandas()
         results = [from_tuple(c) for c in df.itertuples()]
 
         if len(results) == 1:
@@ -87,18 +72,19 @@ class Constellation(SkyObject):
         return None
 
     @classmethod
-    def find(cls, where: list) -> list["Constellation"]:
+    def find(cls, where: list = None, sql: str = None) -> list["Constellation"]:
         """
         Find Constellations
 
         Args:
             where: A list of expressions that determine which constellations to find. See [Selecting Objects](/reference-selecting-objects/) for details.
+            sql: SQL query for selecting constellations (table name is "_")
 
         Returns:
             List of Constellations that match all `where` expressions
 
         """
-        df = constellations.load(filters=where).to_pandas()
+        df = constellations.load(filters=where, sql=sql).to_pandas()
 
         return [from_tuple(c) for c in df.itertuples()]
 
@@ -108,11 +94,13 @@ class Constellation(SkyObject):
 
 
 def from_tuple(c: tuple) -> Constellation:
-    return Constellation(
+    c = Constellation(
         ra=c.ra,
         dec=c.dec,
-        iau_id=c.iau_id,
+        iau_id=c.iau_id.lower(),
         name=c.name,
         star_hip_ids=c.star_hip_ids,
         boundary=c.geometry,
     )
+    c._constellation_id = c.iau_id
+    return c

starplot/models/dso.py

@@ -1,39 +1,80 @@
-from typing import Optional, Union, Iterator
+from typing import Optional, Iterator
+from enum import Enum
 
 from ibis import _
-from shapely.geometry import Polygon, MultiPolygon
 
 from starplot.data.dsos import load
 from starplot.mixins import CreateMapMixin, CreateOpticMixin
-from starplot.models.base import SkyObject
+from starplot.models.base import SkyObject, ShapelyPolygon, ShapelyMultiPolygon
 
 
-class DsoType:
+class DsoType(str, Enum):
     """
-    Type of deep sky object (DSOs), as designated in OpenNGC
+    Type of deep sky object (DSO), as designated in OpenNGC
     """
 
     STAR = "*"
+    """Star"""
+
     DOUBLE_STAR = "**"
+    """Double star or multiple star system"""
+
     ASSOCIATION_OF_STARS = "*Ass"
+    """Association of stars"""
+
     OPEN_CLUSTER = "OCl"
+    """Open cluster of stars"""
+
     GLOBULAR_CLUSTER = "GCl"
+    """Globular cluster of stars"""
+
     GALAXY = "G"
+    """Galaxy"""
+
     GALAXY_PAIR = "GPair"
+    """Group of two galaxies"""
+
     GALAXY_TRIPLET = "GTrpl"
+    """Group of three galaxies"""
+
     GROUP_OF_GALAXIES = "GGroup"
+    """Group of more than three galaxies"""
+
     NEBULA = "Neb"
+    """Nebula"""
+
     PLANETARY_NEBULA = "PN"
+    """Planetary nebula"""
+
     EMISSION_NEBULA = "EmN"
+    """Emission Nebula"""
+
     STAR_CLUSTER_NEBULA = "Cl+N"
+    """Star cluster with nebulosity"""
+
     REFLECTION_NEBULA = "RfN"
+    """Reflection nebula"""
+
     DARK_NEBULA = "DrkN"
+    """Dark nebula"""
+
     HII_IONIZED_REGION = "HII"
+    """Hydrogen ionized region"""
+
     SUPERNOVA_REMNANT = "SNR"
+    """Supernova remnant"""
+
     NOVA_STAR = "Nova"
+    """Nova star"""
+
     NONEXISTENT = "NonEx"
+    """Non-existant object"""
+
     UNKNOWN = "Other"
+    """Unknown type of object"""
+
     DUPLICATE_RECORD = "Dup"
+    """Duplicate record of another object"""
 
 
 class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
@@ -78,39 +119,9 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
     Index Catalogue (IC) identifier. *Note that this field is a string, to support objects like '4974 NED01'.*
     """
 
-    geometry: Union[Polygon, MultiPolygon] = None
+    geometry: ShapelyPolygon | ShapelyMultiPolygon = None
     """Shapely Polygon of the DSO's extent. Right ascension coordinates are in degrees (0...360)."""
 
-    def __init__(
-        self,
-        ra: float,
-        dec: float,
-        name: str,
-        type: DsoType,
-        magnitude: float = None,
-        maj_ax: float = None,
-        min_ax: float = None,
-        angle: float = None,
-        size: float = None,
-        m: str = None,
-        ngc: str = None,
-        ic: str = None,
-        geometry: Union[Polygon, MultiPolygon] = None,
-        constellation_id: str = None,
-    ) -> None:
-        super().__init__(ra, dec, constellation_id)
-        self.name = name
-        self.type = type
-        self.magnitude = magnitude
-        self.maj_ax = maj_ax
-        self.min_ax = min_ax
-        self.angle = angle
-        self.size = size
-        self.m = m
-        self.ngc = ngc
-        self.ic = ic
-        self.geometry = geometry
-
     def __repr__(self) -> str:
         return f"DSO(name={self.name}, magnitude={self.magnitude})"
 
@@ -122,7 +133,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
             yield from_tuple(d)
 
     @classmethod
-    def get(cls, **kwargs) -> "DSO":
+    def get(cls, sql: str = None, **kwargs) -> "DSO":
         """
         Get a DSO, by matching its attributes.
 
@@ -131,6 +142,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
             d = DSO.get(m=13)
 
         Args:
+            sql: SQL query for selecting DSO (table name is "_")
             **kwargs: Attributes on the DSO you want to match
 
         Raises: `ValueError` if more than one DSO is matched
@@ -140,7 +152,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         for k, v in kwargs.items():
             filters.append(getattr(_, k) == v)
 
-        df = load(filters=filters).to_pandas()
+        df = load(filters=filters, sql=sql).to_pandas()
 
         results = [from_tuple(d) for d in df.itertuples()]
 
@@ -155,18 +167,19 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         return None
 
     @classmethod
-    def find(cls, where: list) -> list["DSO"]:
+    def find(cls, where: list = None, sql: str = None) -> list["DSO"]:
         """
         Find DSOs
 
         Args:
             where: A list of expressions that determine which DSOs to find. See [Selecting Objects](/reference-selecting-objects/) for details.
+            sql: SQL query for selecting DSOs (table name is "_")
 
         Returns:
             List of DSOs that match all `where` expressions
 
         """
-        df = load(filters=where).to_pandas()
+        df = load(filters=where, sql=sql).to_pandas()
         return [from_tuple(d) for d in df.itertuples()]
 
 
@@ -185,8 +198,8 @@ def from_tuple(d: tuple) -> DSO:
         ngc=d.ngc,
         ic=d.ic,
         geometry=d.geometry,
-        constellation_id=d.constellation_id,
     )
+    dso._constellation_id = d.constellation_id
     dso._row_id = getattr(d, "rowid", None)
     return dso
 

starplot/models/moon.py

@@ -4,10 +4,9 @@ from enum import Enum
 import numpy as np
 from skyfield.api import Angle, wgs84
 from skyfield import almanac
-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
 
@@ -35,7 +34,7 @@ class Moon(SkyObject):
     """Date/time of moon's position"""
 
     apparent_size: float
-    """Apparent size (degrees)"""
+    """Apparent size in the sky (degrees)"""
 
     phase_angle: float
     """Angle of the moon from the Sun (degrees)"""
@@ -44,31 +43,10 @@ class Moon(SkyObject):
     """Description of the moon's phase. The Moon will be considered New/Full/Quarter if it's within 12 hours of that precise phase."""
 
     illumination: float
-    """Percent of illumination (0...1)"""
-
-    geometry: Polygon = None
-    """Shapely Polygon of the moon's extent. Right ascension coordinates are in degrees (0...360)."""
-
-    def __init__(
-        self,
-        ra: float,
-        dec: float,
-        name: str,
-        dt: datetime,
-        apparent_size: float,
-        phase_angle: float,
-        phase_description: str,
-        illumination: str,
-        geometry: Polygon = None,
-    ) -> None:
-        super().__init__(ra, dec)
-        self.name = name
-        self.dt = dt
-        self.apparent_size = apparent_size
-        self.phase_angle = phase_angle
-        self.phase_description = phase_description
-        self.illumination = illumination
-        self.geometry = geometry
+    """Percent of illumination (0 to 1)"""
+
+    geometry: ShapelyPolygon = None
+    """Shapely Polygon of the moon's extent. Right ascension coordinates are in degrees (0 to 360)."""
 
     @classmethod
     def get(

starplot/models/planet.py

@@ -5,10 +5,9 @@ from typing import Iterator
 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
 
@@ -72,24 +71,9 @@ class Planet(SkyObject):
     apparent_size: float
     """Apparent size (degrees)"""
 
-    geometry: Polygon = None
+    geometry: ShapelyPolygon = None
     """Shapely Polygon of the planet'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 all(
         cls,

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,
     ):
@@ -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

@@ -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:

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))
@@ -92,12 +92,12 @@ class DsoPlotterMixin:
         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.HII_IONIZED_REGION,
+            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))
@@ -113,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
@@ -125,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
@@ -143,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,
     ):
@@ -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/styles/base.py

@@ -169,6 +169,7 @@ class MarkerSymbolEnum(str, Enum):
             MarkerSymbolEnum.CIRCLE_DOTTED_RINGS: circle_dotted_rings(),
             MarkerSymbolEnum.CIRCLE_LINE: circle_line(),
             MarkerSymbolEnum.COMET: "$\u2604$",
+            MarkerSymbolEnum.STAR_4: "$\u2726$",
             MarkerSymbolEnum.STAR_8: "$\u2734$",
             MarkerSymbolEnum.ELLIPSE: ellipse(),
         }[self.value]

{starplot-0.15.6.dist-info → starplot-0.15.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: starplot
-Version: 0.15.6
+Version: 0.15.8
 Summary: Star charts and maps of the sky
 Keywords: astronomy,stars,charts,maps,constellations,sky,plotting
 Author-email: Steve Berardi <hello@steveberardi.com>

{starplot-0.15.6.dist-info → starplot-0.15.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-starplot/__init__.py,sha256=HcBm5p7wfCcnsDaBPmpDAwcunStcLJSiZPoKfHZ2qUI,558
+starplot/__init__.py,sha256=vOqisTpc-0yKEJR9jKWJKoQC__x8vg_PRaKi8MT9Cgc,558
 starplot/base.py,sha256=s-mixdIBeT5QcKYuGXy52oBrg7wJO2rpmHmXqorex1c,43223
 starplot/callables.py,sha256=_zDGCAJTqqNLvCtcIt4PVEe2L0Ggvl6pj-7ZFI-0zqI,4043
 starplot/cli.py,sha256=W-V-h1DeD8zwzdhYuQ-i26LSZWYcS_NJ0zRXa-dmy1o,711
@@ -8,8 +8,8 @@ starplot/geometry.py,sha256=wr1vJo-WWP51bfblVC2CAR7288yWrG31dZg9ks9vfYg,4359
 starplot/horizon.py,sha256=vsJCsJE5VJEe0vlx6A-L70LAGjbey9xMjgUcRSj1F4Y,15808
 starplot/map.py,sha256=CIJC2CoAhH4SlV-dgLC4xDqCoyqXl7DOGegZafRIoqU,23441
 starplot/mixins.py,sha256=8X-LhFbsVNBZN1PKIjlftknppRpcQMOMYE15gdNC-sE,4857
-starplot/optic.py,sha256=NlZZBHRX13KHingNiofv6XDXWUZ4yKH7StBUHuSX_vc,15406
-starplot/optics.py,sha256=JfSzfrCx_g8r3upyukgJUtXekwyVkCJ3dZxdOclfzU4,8624
+starplot/optic.py,sha256=aj7Ks8np6f6aefqGtNHbxk3mwcUydhNAsZAo5qO2OBU,15568
+starplot/optics.py,sha256=v94Ff8bIruVBrME7lzwORlayadpoFIGQsAK0sFlx43Y,9314
 starplot/profile.py,sha256=V5LOZFDdnGo-P8ikWvV3jmUVJIKO3gd4H2bjBlk7aUM,300
 starplot/projections.py,sha256=o5wHLoaU8o0s0Z2kkWKxeNbOrskvWG88ULAXDoLOGeA,3423
 starplot/settings.py,sha256=DCylQwkrgUki1yHrelMF483t98NIDQ1bivCeWfeknJw,627
@@ -19,32 +19,32 @@ starplot/data/__init__.py,sha256=3M_uHlwyIsc9cyfabnOp-6CoXoMteYAaWuj4St9_1BE,308
 starplot/data/bigsky.py,sha256=SiHzzhoy-DAZpJ-Q_-lmJqHRLwTKgosaVOEXYWQ94PI,2820
 starplot/data/constellation_lines.py,sha256=RLyFSoxGRL7kj9gGT4DDUubClKZEDu5wGUMG3PlpYfY,19344
 starplot/data/constellation_stars.py,sha256=l2GeyJWuVtzH-MIw1oGR6jeMBvfqX-q-S2V_ilcEZG8,38221
-starplot/data/constellations.py,sha256=E-wEyZ4W5lcUS_StH26F9NMRsFyFs-utGxGcfRK7zBk,15484
+starplot/data/constellations.py,sha256=05fjaLy5gBDQYyxMV_Etq2O2OMzOh0ozYWT_BwNmfMc,15745
 starplot/data/db.py,sha256=77oWr2HkZ95K_mG4vLc-ivP_SOFIiFYwoqrtTw-YWtk,384
-starplot/data/dsos.py,sha256=tx-6oDzKPthg-nxfda2ah5t10USdyrckP4UjM5k-e10,1237
+starplot/data/dsos.py,sha256=Tc264aSA3J8eVmVTUhjrMYMkijP870dqaleMk7xr3hE,1509
 starplot/data/ecliptic.py,sha256=Qre9YdFbTC9mAx-vd2C0Ou4CsnRehIScnTpmEUDDYcM,4638
-starplot/data/stars.py,sha256=iM0zWqjQe8L8rAekFY0FtPXRutnK6Nv4jhoV6m8983g,12077
+starplot/data/stars.py,sha256=ImcD0lwGgnOlVICQyM62nXVHoSvkS82x1TNIldFprCU,12288
 starplot/data/utils.py,sha256=RPk3bnfL-KtjMk1VQygDD27INz_gEya_B1hu7X4K8hU,772
 starplot/data/library/bigsky.0.4.0.stars.mag11.parquet,sha256=-_D6bghArUh1cmOKktxmmBFQNThiCWjVleI0wduP1GI,38884673
 starplot/data/library/de421_2001.bsp,sha256=ymkZigAd8Vgscq_DYkdR4nZ1VGD5wwPd-sxe6HiiTns,5341104
-starplot/data/library/sky.db,sha256=gbige0EAs5meX_x3DWPuKO23KiKeujGfIh61pfh_OG4,38023168
+starplot/data/library/sky.db,sha256=yl-pokiPUgHvlek7HhAbURwz4NFQ8N7WgX0b1oYjYrk,38023168
 starplot/models/__init__.py,sha256=qi4arVatzEcR9TAbHadSbhq8xRhSb1_Br3UKNv4FP7o,330
-starplot/models/base.py,sha256=zuHcRSs4eSyIwtyUTsAk9a73bnIW2gfWh7Ze_zt8Tq0,1623
-starplot/models/constellation.py,sha256=qfBcWyQRL2m83wNIKiPk-4bGRblYvabxymW6TJ0nXFI,3355
-starplot/models/dso.py,sha256=KHd5N6F2Y7EhO3RWUpmjfl_162uwNqhlC1Zqh9p0Ev4,6942
-starplot/models/moon.py,sha256=FNIzdSMV-5ET7WtmSxWz_4n-U4IlIomQpGTbOMl7fxk,5104
+starplot/models/base.py,sha256=sQ_qTUOUfGxtgLdJVnSbMG328_d_AO5GSIcnC-e0m80,2681
+starplot/models/constellation.py,sha256=ayIGfafFs2eymWHlFdDgZPJkx115x_avPC1egqVZWnI,3220
+starplot/models/dso.py,sha256=ZcAlMn5-y3A_IxfCjhMxmmQzSBeXbxb_P-Jw8T4DQPI,7022
+starplot/models/moon.py,sha256=dW0N70DFx4yO9Zawfo96Z3LZxzLTMZDDpBHrP9rqfa0,4546
 starplot/models/objects.py,sha256=BXwUMT-zPiOYBWYV7L-TRDfPo6lsx_AIk3yxJ3qi0ck,683
-starplot/models/planet.py,sha256=QekNlSRw6tv5-TY8qUFvtLKxmz7ao6nv3Iwl7FiGeHY,5014
-starplot/models/star.py,sha256=7LPlqZInBdu4D5XH2sJDiM6IJvtyVDAZvijMMH5hGAY,4693
-starplot/models/sun.py,sha256=iUforZSmzw-o_tOKHgYslhFHUQTQxllDKMG1HdzlI98,2695
+starplot/models/planet.py,sha256=TyPGMQnlq4NwMXNSRrIgbpL4rAWTdKyNeo5jpSR0Crg,4661
+starplot/models/star.py,sha256=gw36P1BB9qq4IfvS4TqcZsmltKeNWvcnw87wSDxmE1w,4555
+starplot/models/sun.py,sha256=3EaRJclmYX-jhSJav5nGCazH-9_YHT6Qr2irDSsC63I,2342
 starplot/plotters/__init__.py,sha256=p2wpyY_jK5_zOWWbGtokw4tcHBTuILjAhuobghDvdvM,223
-starplot/plotters/constellations.py,sha256=IDVVfEsNPbPC4E692bgr-bQqiV8mQuu18BFZKYHMV_k,13094
-starplot/plotters/dsos.py,sha256=AtqhphVOfjuYZtxmgF18d3jzTYaIv2j6xnZCO9anpds,8406
+starplot/plotters/constellations.py,sha256=ZkI3VfbI7yZfuzg3vG8de4AdxzolXgRj8gBDzwfiHo0,13274
+starplot/plotters/dsos.py,sha256=u_V6b9ADk2YnqwXM6YNayju4SWxe1kLKKT-cMLJva5Y,9095
 starplot/plotters/experimental.py,sha256=P4T9jJyAnViv6k2RJpmYEY8uI-0dyd-E6NeIRUWbu6c,5909
 starplot/plotters/milkyway.py,sha256=ofenSqpqeeg7_LlWnH1PJiiHstzD-qQL7Lk6-WlEv2M,1122
-starplot/plotters/stars.py,sha256=AB3O16Ql38z3_ityAJJljzRtnVixvZ22kaJAXqj4hNs,11710
+starplot/plotters/stars.py,sha256=4k_OUMiNuGT28cMZfm-R9kMzUptPgtW55iqB9vH9WBo,12441
 starplot/styles/__init__.py,sha256=rtwzAylENUGIYGDPl106RGjU6e89yNURoxmPD3I_HM0,193
-starplot/styles/base.py,sha256=fuj_hWqF5xViJMhisyRCh88YRNHCcvxIqGeBlBIm6cw,36405
+starplot/styles/base.py,sha256=eSVITtg_dGp8ChI4pm4g3glpiW_Pd0irwNGQp9HND3g,36454
 starplot/styles/extensions.py,sha256=Mv9FTSbwEtB4IFuo_5MFDlHRYQsKdC-19uLYtmJSUuE,649
 starplot/styles/fonts.py,sha256=wC3cHuFkBUaZM5fKpT_ExV7anrRKMJX46mjEfcSRQMU,379
 starplot/styles/helpers.py,sha256=AGgHWaHLzJZ6jicvwPzY-p5oSHE0H8gDk1raCmeRFtg,3032
@@ -92,8 +92,8 @@ starplot/styles/fonts-library/inter/Inter-SemiBoldItalic.ttf,sha256=HhKJRT16iVz7
 starplot/styles/fonts-library/inter/Inter-Thin.ttf,sha256=TDktzIrZFvD533VZq1VjsB3ZT587LbNGF_45LgAGAzk,403404
 starplot/styles/fonts-library/inter/Inter-ThinItalic.ttf,sha256=X8Ca-UpEf65vgsAPFd-u-ernxWDmy-RtPoRSQBmldKo,410232
 starplot/styles/fonts-library/inter/LICENSE.txt,sha256=JiSB6ERSGzJvXs0FPlm5jIstp4yO4b27boF0MF5Uk1o,4380
-starplot-0.15.6.dist-info/entry_points.txt,sha256=Sm6jC6h_RcaMGC8saLnYmT0SdhcF9_rMeQIiHneLHyc,46
-starplot-0.15.6.dist-info/licenses/LICENSE,sha256=jcjClHF4BQwhz-kDgia-KphO9Zxu0rCa2BbiA7j1jeU,1070
-starplot-0.15.6.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
-starplot-0.15.6.dist-info/METADATA,sha256=dirAqiVfN0z6zfJ62tMAssHoQEBDULtzfms5WWM2Ijs,4276
-starplot-0.15.6.dist-info/RECORD,,
+starplot-0.15.8.dist-info/entry_points.txt,sha256=Sm6jC6h_RcaMGC8saLnYmT0SdhcF9_rMeQIiHneLHyc,46
+starplot-0.15.8.dist-info/licenses/LICENSE,sha256=jcjClHF4BQwhz-kDgia-KphO9Zxu0rCa2BbiA7j1jeU,1070
+starplot-0.15.8.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+starplot-0.15.8.dist-info/METADATA,sha256=w1KjXfQySDtPeNVmkQRP2HZsQD8TxlQwtSWVGW4wK3w,4276
+starplot-0.15.8.dist-info/RECORD,,