starplot 0.14.0__py2.py3-none-any.whl → 0.15.1__py2.py3-none-any.whl

starplot/mixins.py

@@ -1,34 +1,95 @@
+from functools import cache
+
 from shapely import Polygon, MultiPolygon
 
 
 class ExtentMaskMixin:
+    @cache
     def _extent_mask(self):
         """
         Returns shapely geometry objects of extent (RA = 0...360)
 
-        If the extent crosses equinox, then two Polygons will be returned
+        If the extent crosses equinox, then a MultiPolygon will be returned
         """
-        if self.ra_max < 24:
+        if self.ra_max <= 360:
             coords = [
-                [self.ra_min * 15, self.dec_min],
-                [self.ra_max * 15, self.dec_min],
-                [self.ra_min * 15, self.dec_max],
-                [self.ra_max * 15, self.dec_max],
+                [self.ra_min, self.dec_min],
+                [self.ra_max, self.dec_min],
+                [self.ra_max, self.dec_max],
+                [self.ra_min, self.dec_max],
+                [self.ra_min, self.dec_min],
             ]
             return Polygon(coords)
 
         else:
             coords_1 = [
-                [self.ra_min * 15, self.dec_min],
+                [self.ra_min, self.dec_min],
                 [360, self.dec_min],
-                [self.ra_min * 15, self.dec_max],
                 [360, self.dec_max],
+                [self.ra_min, self.dec_max],
+                [self.ra_min, self.dec_min],
             ]
             coords_2 = [
                 [0, self.dec_min],
-                [(self.ra_max - 24) * 15, self.dec_min],
+                [(self.ra_max - 360), self.dec_min],
+                [(self.ra_max - 360), self.dec_max],
                 [0, self.dec_max],
-                [(self.ra_max - 24) * 15, self.dec_max],
+                [0, self.dec_min],
+            ]
+
+            return MultiPolygon(
+                [
+                    Polygon(coords_1),
+                    Polygon(coords_2),
+                ]
+            )
+
+    @cache
+    def _extent_mask_altaz(self):
+        """
+        Returns shapely geometry objects of the alt/az extent
+
+        If the extent crosses North cardinal direction, then a MultiPolygon will be returned
+        """
+        extent = list(self.ax.get_extent(crs=self._plate_carree))
+        alt_min, alt_max = extent[2], extent[3]
+        az_min, az_max = extent[0], extent[1]
+
+        if az_min < 0:
+            az_min += 360
+        if az_max < 0:
+            az_max += 360
+
+        if az_min >= az_max:
+            az_max += 360
+
+        self.az = (az_min, az_max)
+        self.alt = (alt_min, alt_max)
+
+        if az_max <= 360:
+            coords = [
+                [az_min, alt_min],
+                [az_max, alt_min],
+                [az_max, alt_max],
+                [az_min, alt_max],
+                [az_min, alt_min],
+            ]
+            return Polygon(coords)
+
+        else:
+            coords_1 = [
+                [az_min, alt_min],
+                [360, alt_min],
+                [360, alt_max],
+                [az_min, alt_max],
+                [az_min, alt_min],
+            ]
+            coords_2 = [
+                [0, alt_min],
+                [az_max - 360, alt_min],
+                [az_max - 360, alt_max],
+                [0, alt_max],
+                [0, alt_min],
             ]
 
             return MultiPolygon(
@@ -43,7 +104,7 @@ class ExtentMaskMixin:
         return all(
             [
                 self.ra_min == 0,
-                self.ra_max == 24,
+                self.ra_max == 360,
                 self.dec_min == -90,
                 self.dec_max == 90,
             ]
@@ -71,14 +132,14 @@ class CreateMapMixin:
             height_degrees=height_degrees,
             width_degrees=width_degrees,
         )
-        ra_min = ex[0][0] / 15
-        ra_max = ex[2][0] / 15
+        ra_min = ex[0][0]
+        ra_max = ex[2][0]
         dec_min = ex[0][1]
         dec_max = ex[2][1]
 
         # handle wrapping
         if ra_max < ra_min:
-            ra_max += 24
+            ra_max += 360
 
         p = MapPlot(
             ra_min=ra_min,

starplot/models/__init__.py

@@ -1,5 +1,5 @@
 from .constellation import Constellation  # noqa: F401,F403
-from .dso import DSO  # noqa: F401,F403
+from .dso import DSO, DsoType  # noqa: F401,F403
 from .star import Star  # noqa: F401,F403
 from .planet import Planet  # noqa: F401,F403
 from .moon import Moon  # noqa: F401,F403

starplot/models/base.py

@@ -1,114 +1,23 @@
+from functools import cache
 from typing import Optional
-from abc import ABC, abstractmethod
 
 from skyfield.api import position_of_radec, load_constellation_map
 
 from starplot.mixins import CreateMapMixin, CreateOpticMixin
 
-constellation_at = load_constellation_map()
 
+@cache
+def constellation_at():
+    return load_constellation_map()
 
-class Expression:
-    def __init__(self, func=None) -> None:
-        self.func = func
 
-    def evaluate(self, obj):
-        return self.func(obj)
-
-    def __or__(self, other):
-        return Expression(func=lambda d: self.evaluate(d) or other.evaluate(d))
-
-    def __and__(self, other):
-        return Expression(func=lambda d: self.evaluate(d) and other.evaluate(d))
-
-
-class Term:
-    def _factory(self, func):
-        def exp(c):
-            value = getattr(c, self.attr)
-
-            if value is None:
-                return False
-
-            return func(value)
-
-        return Expression(func=exp)
-
-    def __init__(self, attr):
-        self.attr = attr
-
-    def __eq__(self, other):
-        return Expression(
-            func=lambda c: getattr(c, self.attr) == other
-            if other is not None
-            else getattr(c, self.attr) is None
-        )
-
-    def __ne__(self, other):
-        return Expression(
-            func=lambda c: getattr(c, self.attr) != other
-            if other is not None
-            else getattr(c, self.attr) is not None
-        )
-
-    def __lt__(self, other):
-        return self._factory(lambda value: value < other)
-
-    def __le__(self, other):
-        return self._factory(lambda value: value <= other)
-
-    def __gt__(self, other):
-        return self._factory(lambda value: value > other)
-
-    def __ge__(self, other):
-        return self._factory(lambda value: value >= other)
-
-    def is_in(self, other):
-        """Returns `True` if the field's value is in `other`"""
-        return Expression(func=lambda c: getattr(c, self.attr) in other)
-
-    def is_not_in(self, other):
-        """Returns `True` if the field's value is NOT in `other`"""
-        return Expression(func=lambda c: getattr(c, self.attr) not in other)
-
-    def is_null(self):
-        """Returns `True` if the field value is `None`"""
-        return Expression(func=lambda c: getattr(c, self.attr) is None)
-
-    def is_not_null(self):
-        """Returns `True` if the field value is NOT `None`"""
-        return Expression(func=lambda c: getattr(c, self.attr) is not None)
-
-    def intersects(self, other):
-        """Returns `True` if the field's value intersects `other`. Only available for geometry-type fields."""
-        return Expression(func=lambda c: getattr(c, self.attr).intersects(other))
-
-
-class Meta(type):
-    managers = {}
-
-    def __new__(cls, name, bases, attrs):
-        new_cls = super().__new__(cls, name, bases, attrs)
-
-        if "_manager" in attrs:
-            Meta.managers[new_cls] = attrs["_manager"]
-
-        return new_cls
-
-    def __getattribute__(cls, attr):
-        if attr in ["get", "find", "all"]:
-            return getattr(Meta.managers[cls], attr)
-
-        return Term(attr)
-
-
-class SkyObject(CreateMapMixin, CreateOpticMixin, metaclass=Meta):
+class SkyObject(CreateMapMixin, CreateOpticMixin):
     """
     Basic sky object model.
     """
 
     ra: float
-    """Right Ascension, in hours (0...24)"""
+    """Right Ascension, in degrees (0...360)"""
 
     dec: float
     """Declination, in degrees (-90...90)"""
@@ -118,16 +27,18 @@ class SkyObject(CreateMapMixin, CreateOpticMixin, metaclass=Meta):
     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)."""
 
-    def __init__(self, ra: float, dec: float) -> None:
+    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
 
     @property
     def constellation_id(self):
         """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)
-            self._constellation_id = constellation_at(pos).lower()
+            self._constellation_id = constellation_at()(pos).lower()
         return self._constellation_id
 
     def constellation(self):
@@ -135,32 +46,3 @@ class SkyObject(CreateMapMixin, CreateOpticMixin, metaclass=Meta):
         from starplot.models import Constellation
 
         return Constellation.get(iau_id=self.constellation_id)
-
-
-class SkyObjectManager(ABC):
-    @abstractmethod
-    def all(cls, *args, **kwargs):
-        raise NotImplementedError
-
-    @classmethod
-    def find(cls, where, **kwargs):
-        all_objects = kwargs.pop("all_objects", None) or cls.all()
-        return [s for s in all_objects if all([e.evaluate(s) for e in where])]
-
-    @classmethod
-    def get(cls, **kwargs):
-        all_objects = kwargs.pop("all_objects", None) or cls.all()
-        matches = [
-            s
-            for s in all_objects
-            if all([getattr(s, kw) == value for kw, value in kwargs.items()])
-        ]
-
-        if len(matches) == 1:
-            return matches[0]
-        elif len(matches) > 1:
-            raise ValueError(
-                "More than one match. Use find() instead or narrow your search."
-            )
-        else:
-            return None

starplot/models/constellation.py

@@ -1,16 +1,10 @@
-from shapely import Polygon
-
-from starplot.models.base import SkyObject, SkyObjectManager
-from starplot.models.geometry import to_24h
-from starplot.data import constellations
+from typing import Union, Iterator
 
+from ibis import _
+from shapely import Polygon, MultiPolygon
 
-class ConstellationManager(SkyObjectManager):
-    @classmethod
-    def all(cls):
-        all_constellations = constellations.load()
-        for constellation in all_constellations.itertuples():
-            yield from_tuple(constellation)
+from starplot.models.base import SkyObject
+from starplot.data import constellations
 
 
 class Constellation(SkyObject):
@@ -18,16 +12,22 @@ class Constellation(SkyObject):
     Constellation model.
     """
 
-    _manager = ConstellationManager
-
     iau_id: str = None
-    """International Astronomical Union (IAU) three-letter designation, all lowercase"""
+    """
+    International Astronomical Union (IAU) three-letter designation, all lowercase.
+    
+    **Important**: Starplot treats Serpens as two separate constellations to make them easier to work with programatically. 
+    Serpens Caput has the `iau_id` of `ser1` and Serpens Cauda is `ser2`
+    """
 
     name: str = None
     """Name"""
 
-    boundary: Polygon = None
-    """Shapely Polygon of the constellation's boundary. Right ascension coordinates are in 24H format."""
+    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
+    """Shapely Polygon of the constellation's boundary. Right ascension coordinates are in degrees (0...360)."""
 
     def __init__(
         self,
@@ -35,33 +35,59 @@ class Constellation(SkyObject):
         dec: float,
         iau_id: str,
         name: str = None,
+        star_hip_ids: list[int] = None,
         boundary: Polygon = None,
     ) -> None:
-        super().__init__(ra, dec)
+        super().__init__(ra, dec, constellation_id=iau_id.lower())
         self.iau_id = iau_id.lower()
-        self._constellation_id = self.iau_id  # override from super()
         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})"
 
     @classmethod
-    def get(**kwargs) -> "Constellation":
+    def all(cls) -> Iterator["Constellation"]:
+        df = constellations.load().to_pandas()
+
+        for c in df.itertuples():
+            yield from_tuple(c)
+
+    @classmethod
+    def get(cls, **kwargs) -> "Constellation":
         """
         Get a Constellation, by matching its attributes.
 
-        Example: `hercules = Constellation.get(name="Hercules")`
+        Example:
+
+            hercules = Constellation.get(name="Hercules")
 
         Args:
             **kwargs: Attributes on the constellation you want to match
 
         Raises: `ValueError` if more than one constellation is matched
         """
-        pass
+        filters = []
+
+        for k, v in kwargs.items():
+            filters.append(getattr(_, k) == v)
+
+        df = constellations.load(filters=filters).to_pandas()
+        results = [from_tuple(c) for c in df.itertuples()]
+
+        if len(results) == 1:
+            return results[0]
+
+        if len(results) > 1:
+            raise ValueError(
+                "More than one match. Use find() instead or narrow your search."
+            )
+
+        return None
 
     @classmethod
-    def find(where: list) -> list["Constellation"]:
+    def find(cls, where: list) -> list["Constellation"]:
         """
         Find Constellations
 
@@ -72,7 +98,9 @@ class Constellation(SkyObject):
             List of Constellations that match all `where` expressions
 
         """
-        pass
+        df = constellations.load(filters=where).to_pandas()
+
+        return [from_tuple(c) for c in df.itertuples()]
 
     def constellation(self):
         """Not applicable to Constellation model, raises `NotImplementedError`"""
@@ -80,16 +108,11 @@ class Constellation(SkyObject):
 
 
 def from_tuple(c: tuple) -> Constellation:
-    geometry = c.geometry
-    if len(c.geometry.geoms) == 1:
-        geometry = c.geometry.geoms[0]
-
-    geometry = to_24h(geometry)
-
     return Constellation(
-        ra=c.center_ra / 15,
-        dec=c.center_dec,
+        ra=c.ra,
+        dec=c.dec,
         iau_id=c.iau_id,
         name=c.name,
-        boundary=geometry,
+        star_hip_ids=c.star_hip_ids,
+        boundary=c.geometry,
     )