starplot 0.13.0__py2.py3-none-any.whl → 0.15.0__py2.py3-none-any.whl

starplot/models/dso.py

@@ -1,23 +1,39 @@
-from typing import Optional, Union
+from typing import Optional, Union, Iterator
 
+from ibis import _
 from shapely.geometry import Polygon, MultiPolygon
 
-from starplot.data.dsos import DsoType, load_ongc, ONGC_TYPE_MAP
+from starplot.data.dsos import load
 from starplot.mixins import CreateMapMixin, CreateOpticMixin
-from starplot.models.base import SkyObject, SkyObjectManager
-from starplot.models.geometry import to_24h
-from starplot import geod
+from starplot.models.base import SkyObject
 
 
-class DsoManager(SkyObjectManager):
-    @classmethod
-    def all(cls):
-        all_dsos = load_ongc()
+class DsoType:
+    """
+    Type of deep sky object (DSOs), as designated in OpenNGC
+    """
 
-        for d in all_dsos.itertuples():
-            magnitude = d.mag_v or d.mag_b or None
-            magnitude = float(magnitude) if magnitude else None
-            yield from_tuple(d)
+    STAR = "*"
+    DOUBLE_STAR = "**"
+    ASSOCIATION_OF_STARS = "*Ass"
+    OPEN_CLUSTER = "OCl"
+    GLOBULAR_CLUSTER = "GCl"
+    GALAXY = "G"
+    GALAXY_PAIR = "GPair"
+    GALAXY_TRIPLET = "GTrpl"
+    GROUP_OF_GALAXIES = "GGroup"
+    NEBULA = "Neb"
+    PLANETARY_NEBULA = "PN"
+    EMISSION_NEBULA = "EmN"
+    STAR_CLUSTER_NEBULA = "Cl+N"
+    REFLECTION_NEBULA = "RfN"
+    DARK_NEBULA = "DrkN"
+    HII_IONIZED_REGION = "HII"
+    SUPERNOVA_REMNANT = "SNR"
+    NOVA_STAR = "Nova"
+    NONEXISTENT = "NonEx"
+    UNKNOWN = "Other"
+    DUPLICATE_RECORD = "Dup"
 
 
 class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
@@ -26,12 +42,11 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
     So, you can use any attributes of this model in your callables. Note that some may be null.
     """
 
-    _manager = DsoManager
-
     name: str
     """Name of the DSO (as specified in OpenNGC)"""
 
     type: DsoType
+    """Type of DSO"""
 
     magnitude: Optional[float] = None
     """Magnitude (if available)"""
@@ -64,7 +79,7 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
     """
 
     geometry: Union[Polygon, MultiPolygon] = None
-    """Shapely Polygon of the DSO's extent. Right ascension coordinates are in 24H format."""
+    """Shapely Polygon of the DSO's extent. Right ascension coordinates are in degrees (0...360)."""
 
     def __init__(
         self,
@@ -81,8 +96,9 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         ngc: str = None,
         ic: str = None,
         geometry: Union[Polygon, MultiPolygon] = None,
+        constellation_id: str = None,
     ) -> None:
-        super().__init__(ra, dec)
+        super().__init__(ra, dec, constellation_id)
         self.name = name
         self.type = type
         self.magnitude = magnitude
@@ -99,21 +115,47 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
         return f"DSO(name={self.name}, magnitude={self.magnitude})"
 
     @classmethod
-    def get(**kwargs) -> "DSO":
+    def all(cls) -> Iterator["DSO"]:
+        df = load().to_pandas()
+
+        for d in df.itertuples():
+            yield from_tuple(d)
+
+    @classmethod
+    def get(cls, **kwargs) -> "DSO":
         """
         Get a DSO, by matching its attributes.
 
-        Example: `d = DSO.get(m=13)`
+        Example:
+
+            d = DSO.get(m=13)
 
         Args:
             **kwargs: Attributes on the DSO you want to match
 
         Raises: `ValueError` if more than one DSO is matched
         """
-        pass
+        filters = []
+
+        for k, v in kwargs.items():
+            filters.append(getattr(_, k) == v)
+
+        df = load(filters=filters).to_pandas()
+
+        results = [from_tuple(d) for d 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["DSO"]:
+    def find(cls, where: list) -> list["DSO"]:
         """
         Find DSOs
 
@@ -124,60 +166,83 @@ class DSO(SkyObject, CreateMapMixin, CreateOpticMixin):
             List of DSOs that match all `where` expressions
 
         """
-        pass
-
-
-def create_ellipse(d):
-    maj_ax, min_ax, angle = d.maj_ax, d.min_ax, d.angle
-
-    if maj_ax is None:
-        return d.geometry
-
-    if angle is None:
-        angle = 0
-
-    maj_ax_degrees = (maj_ax / 60) / 2
-
-    if not min_ax:
-        min_ax_degrees = maj_ax_degrees
-    else:
-        min_ax_degrees = (min_ax / 60) / 2
-
-    points = geod.ellipse(
-        (d.ra_degrees / 15, d.dec_degrees),
-        min_ax_degrees * 2,
-        maj_ax_degrees * 2,
-        angle,
-        num_pts=100,
-    )
-
-    # points = [geod.to_radec(p) for p in points]
-    points = [(round(ra, 4), round(dec, 4)) for ra, dec in points]
-    return Polygon(points)
+        df = load(filters=where).to_pandas()
+        return [from_tuple(d) for d in df.itertuples()]
 
 
 def from_tuple(d: tuple) -> DSO:
-    magnitude = d.mag_v or d.mag_b or None
-    magnitude = float(magnitude) if magnitude else None
-    geometry = d.geometry
-
-    if str(geometry.geom_type) not in ["Polygon", "MultiPolygon"]:
-        geometry = create_ellipse(d)
-
-    geometry = to_24h(geometry)
-
-    return DSO(
+    dso = DSO(
         name=d.name,
-        ra=d.ra_degrees / 15,
-        dec=d.dec_degrees,
-        type=ONGC_TYPE_MAP[d.type],
+        ra=d.ra,
+        dec=d.dec,
+        type=d.type,
         maj_ax=d.maj_ax,
         min_ax=d.min_ax,
         angle=d.angle,
-        magnitude=magnitude,
-        size=d.size_deg2,
+        magnitude=d.magnitude,
+        size=d.size,
         m=d.m,
         ngc=d.ngc,
         ic=d.ic,
-        geometry=geometry,
+        geometry=d.geometry,
+        constellation_id=d.constellation_id,
     )
+    dso._row_id = getattr(d, "rowid", None)
+    return dso
+
+
+ONGC_TYPE = {
+    # Star Clusters ----------
+    DsoType.OPEN_CLUSTER: "OCl",
+    DsoType.GLOBULAR_CLUSTER: "GCl",
+    # Galaxies ----------
+    DsoType.GALAXY: "G",
+    DsoType.GALAXY_PAIR: "GPair",
+    DsoType.GALAXY_TRIPLET: "GTrpl",
+    DsoType.GROUP_OF_GALAXIES: "GGroup",
+    # Nebulas ----------
+    DsoType.NEBULA: "Neb",
+    DsoType.PLANETARY_NEBULA: "PN",
+    DsoType.EMISSION_NEBULA: "EmN",
+    DsoType.STAR_CLUSTER_NEBULA: "Cl+N",
+    DsoType.REFLECTION_NEBULA: "RfN",
+    # Stars ----------
+    DsoType.STAR: "*",
+    DsoType.DOUBLE_STAR: "**",
+    DsoType.ASSOCIATION_OF_STARS: "*Ass",
+    # Others
+    DsoType.HII_IONIZED_REGION: "HII",
+    DsoType.DARK_NEBULA: "DrkN",
+    DsoType.SUPERNOVA_REMNANT: "SNR",
+    DsoType.NOVA_STAR: "Nova",
+    DsoType.NONEXISTENT: "NonEx",
+    DsoType.UNKNOWN: "Other",
+    DsoType.DUPLICATE_RECORD: "Dup",
+}
+
+ONGC_TYPE_MAP = {v: k for k, v in ONGC_TYPE.items()}
+
+DSO_LEGEND_LABELS = {
+    # Galaxies ----------
+    DsoType.GALAXY: "Galaxy",
+    DsoType.GALAXY_PAIR: "Galaxy",
+    DsoType.GALAXY_TRIPLET: "Galaxy",
+    DsoType.GROUP_OF_GALAXIES: "Galaxy",
+    # Nebulas ----------
+    DsoType.NEBULA: "Nebula",
+    DsoType.PLANETARY_NEBULA: "Nebula",
+    DsoType.EMISSION_NEBULA: "Nebula",
+    DsoType.STAR_CLUSTER_NEBULA: "Nebula",
+    DsoType.REFLECTION_NEBULA: "Nebula",
+    # Star Clusters ----------
+    DsoType.OPEN_CLUSTER: "Open Cluster",
+    DsoType.GLOBULAR_CLUSTER: "Globular Cluster",
+    # Stars ----------
+    DsoType.DOUBLE_STAR: "Double Star",
+    DsoType.ASSOCIATION_OF_STARS: "Association of stars",
+    DsoType.NOVA_STAR: "Nova Star",
+    # Others
+    DsoType.HII_IONIZED_REGION: "HII Ionized Region",
+    DsoType.DARK_NEBULA: "Dark Nebula",
+    DsoType.SUPERNOVA_REMNANT: "Supernova Remnant",
+}

starplot/models/moon.py

@@ -7,8 +7,8 @@ from skyfield import almanac
 from shapely import Polygon
 
 from starplot.data import load
-from starplot.models.base import SkyObject, SkyObjectManager
-from starplot.models.geometry import circle
+from starplot.models.base import SkyObject
+from starplot.geometry import circle
 from starplot.utils import dt_or_now
 
 
@@ -25,14 +25,50 @@ class MoonPhase(str, Enum):
     WANING_CRESCENT = "Waning Crescent"
 
 
-class MoonManager(SkyObjectManager):
-    @classmethod
-    def all(cls):
-        raise NotImplementedError
+class Moon(SkyObject):
+    """Moon model. Only used for Earth's moon right now, but will potentially represent other planets' moons in future versions."""
 
-    @classmethod
-    def find(cls):
-        raise NotImplementedError
+    name: str = "Moon"
+    """Name of the moon"""
+
+    dt: datetime
+    """Date/time of moon's position"""
+
+    apparent_size: float
+    """Apparent size (degrees)"""
+
+    phase_angle: float
+    """Angle of the moon from the Sun (degrees)"""
+
+    phase_description: str
+    """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
 
     @classmethod
     def get(
@@ -41,7 +77,16 @@ class MoonManager(SkyObjectManager):
         lat: float = None,
         lon: float = None,
         ephemeris: str = "de421_2001.bsp",
-    ):
+    ) -> "Moon":
+        """
+        Get the Moon for a specific date/time and observing location.
+
+        Args:
+            dt: Datetime you want the moon for (must be timezone aware!). _Defaults to current UTC time_.
+            lat: Latitude of observing location. If you set this (and longitude), then the Moon's _apparent_ RA/DEC will be calculated.
+            lon: Longitude of observing location
+            ephemeris: Ephemeris to use for calculating moon positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
+        """
         RADIUS_KM = 1_740
 
         dt = dt_or_now(dt)
@@ -106,7 +151,7 @@ class MoonManager(SkyObjectManager):
             phase = MoonPhase.WANING_CRESCENT
 
         return Moon(
-            ra=ra.hours,
+            ra=ra.hours * 15,
             dec=dec.degrees,
             name="Moon",
             dt=dt,
@@ -114,71 +159,5 @@ class MoonManager(SkyObjectManager):
             phase_angle=phase_angle,
             phase_description=phase.value,
             illumination=illumination,
-            geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
+            geometry=circle((ra.hours * 15, dec.degrees), apparent_diameter_degrees),
         )
-
-
-class Moon(SkyObject):
-    """Moon model. Only used for Earth's moon right now, but will potentially represent other planets' moons in future versions."""
-
-    _manager = MoonManager
-
-    name: str = "Moon"
-    """Name of the moon"""
-
-    dt: datetime
-    """Date/time of moon's position"""
-
-    apparent_size: float
-    """Apparent size (degrees)"""
-
-    phase_angle: float
-    """Angle of the moon from the Sun (degrees)"""
-
-    phase_description: str
-    """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 24H format."""
-
-    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
-
-    @classmethod
-    def get(
-        dt: datetime = None,
-        lat: float = None,
-        lon: float = None,
-        ephemeris: str = "de421_2001.bsp",
-    ) -> "Moon":
-        """
-        Get the Moon for a specific date/time and observing location.
-
-        Args:
-            dt: Datetime you want the moon for (must be timezone aware!). _Defaults to current UTC time_.
-            lat: Latitude of observing location. If you set this (and longitude), then the Moon's _apparent_ RA/DEC will be calculated.
-            lon: Longitude of observing location
-            ephemeris: Ephemeris to use for calculating moon positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
-        """
-        pass

starplot/models/planet.py

@@ -8,8 +8,8 @@ from skyfield.api import Angle, wgs84
 from shapely import Polygon
 
 from starplot.data import load
-from starplot.models.base import SkyObject, SkyObjectManager
-from starplot.models.geometry import circle
+from starplot.models.base import SkyObject
+from starplot.geometry import circle
 from starplot.utils import dt_or_now
 
 
@@ -48,73 +48,9 @@ Retrieved on 18-APR-2024
 """
 
 
-class PlanetManager(SkyObjectManager):
-    @classmethod
-    def all(
-        cls,
-        dt: datetime = None,
-        lat: float = None,
-        lon: float = None,
-        ephemeris: str = "de421_2001.bsp",
-    ):
-        dt = dt_or_now(dt)
-        ephemeris = load(ephemeris)
-        timescale = load.timescale().from_datetime(dt)
-        earth = ephemeris["earth"]
-
-        for p in PlanetName:
-            planet = ephemeris[f"{p.value} barycenter"]
-
-            if lat is not None and lon is not None:
-                position = earth + wgs84.latlon(lat, lon)
-                astrometric = position.at(timescale).observe(planet)
-                apparent = astrometric.apparent()
-                ra, dec, distance = apparent.radec()
-            else:
-                astrometric = earth.at(timescale).observe(planet)
-                ra, dec, distance = astrometric.radec()
-
-            # angular diameter:
-            # https://rhodesmill.org/skyfield/examples.html#what-is-the-angular-diameter-of-a-planet-given-its-radius
-            apparent_diameter_degrees = Angle(
-                radians=np.arcsin(PLANET_RADIUS_KM[p] / distance.km) * 2.0
-            ).degrees
-
-            yield Planet(
-                ra=ra.hours,
-                dec=dec.degrees,
-                name=p,
-                dt=dt,
-                apparent_size=apparent_diameter_degrees,
-                geometry=circle((ra.hours, dec.degrees), apparent_diameter_degrees),
-            )
-
-    @classmethod
-    def find(cls):
-        raise NotImplementedError
-
-    @classmethod
-    def get(
-        cls,
-        name: str,
-        dt: datetime = None,
-        lat: float = None,
-        lon: float = None,
-        ephemeris: str = "de421_2001.bsp",
-    ):
-        dt = dt_or_now(dt)
-        for p in cls.all(dt, lat, lon, ephemeris):
-            if p.name.lower() == name.lower():
-                return p
-
-        return None
-
-
 class Planet(SkyObject):
     """Planet model."""
 
-    _manager = PlanetManager
-
     name: str
     """
     Name of the planet:
@@ -137,7 +73,7 @@ class Planet(SkyObject):
     """Apparent size (degrees)"""
 
     geometry: Polygon = None
-    """Shapely Polygon of the planet's extent. Right ascension coordinates are in 24H format."""
+    """Shapely Polygon of the planet's extent. Right ascension coordinates are in degrees (0...360)."""
 
     def __init__(
         self,
@@ -156,6 +92,7 @@ class Planet(SkyObject):
 
     @classmethod
     def all(
+        cls,
         dt: datetime = None,
         lat: float = None,
         lon: float = None,
@@ -170,10 +107,43 @@ class Planet(SkyObject):
             lon: Longitude of observing location
             ephemeris: Ephemeris to use for calculating planet positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
         """
-        pass
+        dt = dt_or_now(dt)
+        ephemeris = load(ephemeris)
+        timescale = load.timescale().from_datetime(dt)
+        earth = ephemeris["earth"]
+
+        for p in PlanetName:
+            planet = ephemeris[f"{p.value} barycenter"]
+
+            if lat is not None and lon is not None:
+                position = earth + wgs84.latlon(lat, lon)
+                astrometric = position.at(timescale).observe(planet)
+                apparent = astrometric.apparent()
+                ra, dec, distance = apparent.radec()
+            else:
+                astrometric = earth.at(timescale).observe(planet)
+                ra, dec, distance = astrometric.radec()
+
+            # angular diameter:
+            # https://rhodesmill.org/skyfield/examples.html#what-is-the-angular-diameter-of-a-planet-given-its-radius
+            apparent_diameter_degrees = Angle(
+                radians=np.arcsin(PLANET_RADIUS_KM[p] / distance.km) * 2.0
+            ).degrees
+
+            yield Planet(
+                ra=ra.hours * 15,
+                dec=dec.degrees,
+                name=p,
+                dt=dt,
+                apparent_size=apparent_diameter_degrees,
+                geometry=circle(
+                    (ra.hours * 15, dec.degrees), apparent_diameter_degrees
+                ),
+            )
 
     @classmethod
     def get(
+        cls,
         name: str,
         dt: datetime = None,
         lat: float = None,
@@ -190,4 +160,9 @@ class Planet(SkyObject):
             lon: Longitude of observing location
             ephemeris: Ephemeris to use for calculating planet positions (see [Skyfield's documentation](https://rhodesmill.org/skyfield/planets.html) for details)
         """
-        pass
+        dt = dt_or_now(dt)
+        for p in cls.all(dt, lat, lon, ephemeris):
+            if p.name.lower() == name.lower():
+                return p
+
+        return None