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

starplot/__init__.py

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

starplot/base.py

@@ -360,6 +360,9 @@ class BasePlot(ABC):
 
         x, y = self._prepare_coords(ra, dec)
         kwargs["path_effects"] = kwargs.get("path_effects", [self.text_border])
+        remove_on_constellation_collision = kwargs.pop(
+            "remove_on_constellation_collision", True
+        )
 
         original_va = kwargs.pop("va", None)
         original_ha = kwargs.pop("ha", None)
@@ -386,7 +389,10 @@ class BasePlot(ABC):
                 x, y, text, **kwargs, va=va, ha=ha, xytext=(offset_x, offset_y)
             )
             removed = self._maybe_remove_label(
-                label, remove_on_collision=hide_on_collision, remove_on_clipped=clip_on
+                label,
+                remove_on_collision=hide_on_collision,
+                remove_on_clipped=clip_on,
+                remove_on_constellation_collision=remove_on_constellation_collision,
             )
 
             if force or not removed:
@@ -868,10 +874,13 @@ class BasePlot(ABC):
             # closed=False, # needs to be false for circles at poles?
             **style.matplot_kwargs(self.scale),
             **kwargs,
-            clip_on=True,
-            clip_path=self._background_clip_path,
+            # clip_on=True,
+            # clip_path=self._background_clip_path,
         )
         self.ax.add_patch(patch)
+        # Need to set clip path AFTER adding patch
+        patch.set_clip_on(True)
+        patch.set_clip_path(self._background_clip_path)
 
     @use_style(PolygonStyle)
     def polygon(

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,