starplot 0.20.5__py3-none-any.whl

starplot/__init__.py

@@ -0,0 +1,59 @@
+# ruff: noqa: F401,F403
+
+"""Star charts and maps of the sky"""
+
+__version__ = "0.20.5"
+
+from .plots import (
+    MapPlot,
+    HorizonPlot,
+    OpticPlot,
+    ZenithPlot,
+    GalaxyPlot,
+)
+from .models import (
+    DSO,
+    DsoType,
+    Star,
+    Constellation,
+    ConstellationBorder,
+    Comet,
+    Planet,
+    Moon,
+    Sun,
+    ObjectList,
+    Scope,
+    Binoculars,
+    Reflector,
+    Refractor,
+    Camera,
+    Satellite,
+    Observer,
+    MilkyWay,
+)
+from .data import Catalog
+from .styles import *
+from .projections import *
+from .config import settings
+from .plotters.text import CollisionHandler
+
+from ibis import _
+
+
+import contextlib
+
+
+@contextlib.contextmanager
+def override_settings(**kwargs):
+    original = {}
+
+    for key, value in kwargs.items():
+        original[key] = getattr(settings, key, None)
+        setattr(settings, key, value)
+
+    try:
+        yield
+
+    finally:
+        for key, value in original.items():
+            setattr(settings, key, value)

starplot/callables.py

@@ -0,0 +1,176 @@
+import math
+
+from typing import Callable
+
+from starplot.models import Star
+from starplot.utils import bv_to_hex_color
+
+
+def size_by_magnitude_factory(
+    threshold: float,
+    over_threshold_size: float,
+    base: float = 20,
+) -> Callable[[Star], float]:
+    """
+    Creates a new version of `size_by_magnitude_log` with a custom threshold and base multiplier:
+
+    ```python
+    if magnitude >= threshold:
+        size = over_threshold_size
+    else:
+        size = base ** math.log(threshold - magnitude)
+    ```
+
+    Args:
+        threshold: The threshold at which size will be a constant value. In other words, if an object's magnitude is more than or equal to this number, then its size will be the constant `under_threshold_size`
+        over_threshold_size: Size for objects that have a magnitude greater than or equal to the treshold
+        base: Base for objects that have a magnitude less than the threshold
+
+    Returns:
+        A callable for calculating size based on magnitude
+
+    """
+
+    def size_fn(star: Star) -> float:
+        m = star.magnitude
+        if m >= threshold:
+            size = over_threshold_size
+        else:
+            size = base ** math.log(threshold - m)
+
+        return size * 9
+
+    return size_fn
+
+
+_size_by_magnitude_default = size_by_magnitude_factory(7.6, 4)
+
+
+def size_by_magnitude_log(star: Star) -> float:
+    """
+    Calculates size by logarithmic scale of magnitude:
+
+    ```python
+    if magnitude >= 7.6:
+        size = 2.36
+    else:
+        size = 20 ** math.log(8 - magnitude)
+    ```
+    """
+    return _size_by_magnitude_default(star)
+
+
+def size_by_magnitude(star: Star) -> float:
+    """
+    Simple sizing by magnitude, using a step size of 1.
+
+    ```python
+    if mag <= 0:
+        size = 3800
+    elif mag <= 1:  # 0..1
+        size = 2400
+    elif mag <= 2:  # 1..2
+        size = 1600
+    elif mag <= 3:  # 2..3
+        size = 1000
+    elif mag <= 4:  # 3..4
+        size = 600
+    elif mag <= 5:  # 4..5
+        size = 300
+    elif mag <= 6:  # 5..6
+        size = 120
+    elif mag <= 7:  # 6..7
+        size = 60
+    elif mag <= 8:  # 7..8
+        size = 40
+    else:           # > 8
+        size = 20
+
+    ```
+    """
+    mag = star.magnitude
+    size = 0
+    if mag <= 0:
+        size = 3800
+    elif mag <= 1:  # 0..1
+        size = 2400
+    elif mag <= 2:  # 1..2
+        size = 1600
+    elif mag <= 3:  # 2..3
+        size = 1000
+    elif mag <= 4:  # 3..4
+        size = 600
+    elif mag <= 5:  # 4..5
+        size = 300
+    elif mag <= 6:  # 5..6
+        size = 120
+    elif mag <= 7:  # 6..7
+        size = 60
+    elif mag <= 8:  # 7..8
+        size = 40
+    else:  # > 8
+        size = 20
+
+    return size
+
+
+def size_by_magnitude_simple(star: Star) -> float:
+    """Very simple sizer by magnitude for map plots"""
+    m = star.magnitude
+    if m < 1.6:
+        return (9 - m) ** 2.85
+    elif m < 4.6:
+        return (8 - m) ** 2.92
+    elif m < 5.8:
+        return (9 - m) ** 2.46
+
+    return 2.23
+
+
+def size_by_magnitude_for_optic(star: Star) -> float:
+    """Very simple sizer by magnitude for optic plots"""
+    m = star.magnitude
+
+    if m < 4.6:
+        return (9 - m) ** 3.6 * 9
+    elif m < 5.85:
+        return (9 - m) ** 3.6 * 9
+    elif m < 9:
+        return (13 - m) ** 1.8 * 9
+
+    return 4.8 * 6
+
+
+def alpha_by_magnitude(star: Star) -> float:
+    """
+    Basic calculator for alpha, based on magnitude:
+
+    ```python
+    if magnitude < 4.6:
+        alpha = 1
+    elif magnitude < 5.8:
+        alpha = 0.9
+    else:
+        alpha = (16 - m) * 0.09
+    ```
+    """
+    m = star.magnitude
+    if m < 4.6:
+        return 1
+    elif m < 5.8:
+        return 0.9
+
+    return (16 - m) * 0.09
+
+
+def color_by_bv(star: Star) -> str:
+    """
+    Calculates color by the object's [B-V index](https://en.wikipedia.org/wiki/Color_index)
+
+    Color hex values from: [Mitchell Charity](http://www.vendian.org/mncharity/dir3/starcolor/details.html)
+    """
+    if math.isnan(star.bv):
+        bv = 0
+    else:
+        bv = star.bv
+    return bv_to_hex_color(bv)

starplot/cli.py

@@ -0,0 +1,29 @@
+import sys
+
+from starplot.styles import fonts
+from starplot.config import settings
+from starplot.data import db
+from starplot.data.catalogs import download_all_catalogs
+
+COMMANDS = ["setup"]
+
+
+def setup(options):
+    print("Installing DuckDB spatial extension...")
+    db.connect()  # installs spatial extension as side-effect
+
+    print("Building font cache...")
+    fonts.load()
+
+    print(f"Downloading data catalogs to: {settings.data_path}")
+    download_all_catalogs()
+
+
+def main():
+    command = sys.argv[1].lower()
+
+    if command not in COMMANDS:
+        print(f"Unrecognized command: {command}")
+
+    if command == "setup":
+        setup(sys.argv[2:])

starplot/config.py

@@ -0,0 +1,80 @@
+import os
+
+from enum import Enum
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+def _get_path(var_name, default) -> Path:
+    def _get():
+        value = os.environ.get(var_name, default)
+        return Path(value)
+
+    return _get
+
+
+def _get_boolean(var_name, default) -> bool:
+    def _get():
+        value = os.environ.get(var_name)
+        return default if not value else bool(value.lower() == "true")
+
+    return _get
+
+
+class SvgTextType(str, Enum):
+    PATH = "path"
+    ELEMENT = "element"
+
+
+@dataclass
+class Settings:
+    data_path: Path = field(default_factory=_get_path("STARPLOT_DATA_PATH", Path.cwd()))
+    """
+    Path that Starplot will use for data and the DuckDB spatial extension, which is required for the data backend.
+    
+    Default = current working directory
+    """
+
+    svg_text_type: SvgTextType = field(
+        default_factory=lambda: os.environ.get(
+            "STARPLOT_SVG_TEXT_TYPE", SvgTextType.PATH
+        )
+    )
+    """
+    Method for rendering text in SVG exports:
+
+    - `"path"` (default) will render all text as paths. This will increase the filesize, 
+    but allow all viewers to see the font correctly (even if they don't have the font 
+    installed on their system).
+
+    - `"element"` will render all text as an [SVG `<text>` element](https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/text), 
+    which means the text will be editable in graphic design applications but the text may render in a system default font if the original 
+    font isn't available. **Important: when using the "element" method, text borders will be turned OFF.**
+    
+    """
+
+    language: str = field(
+        default_factory=lambda: os.environ.get("STARPLOT_LANGUAGE", "en-US")
+    )
+    """
+    Default language for plotted labels, as an ISO-639 code. Case insensitive.
+
+    Supported values:
+
+    - `en-us` = English (default)
+    - `es` = Spanish
+    - `fa` = Persian (Farsi). Make sure you have a Persian font installed that supports RTL (such as [Vazir](https://github.com/rastikerdar/vazir-font) or [Noto Sans Arabic](https://fonts.google.com/noto/specimen/Noto+Sans+Arabic)) and set it as the font in your plot's style.
+    - `fr` = French
+    - `it` = Italian
+    - `lt` = Lithuanian
+    - `zh-cn` = Chinese. Make sure you have a good Chinese font installed (such as [Noto Sans SC](https://fonts.google.com/noto/specimen/Noto+Sans+SC)) and you'll also need to set that as the font in your plot's style.
+    - `zh-tw` = Traditional Chinese
+
+    **🌐 Want to see another language available? Please help us add it! [Details here](https://github.com/steveberardi/starplot/tree/main/data/raw/translations).**
+    """
+
+    debug: bool = field(default_factory=_get_boolean("STARPLOT_DEBUG", False))
+    """Global setting for debug mode. When this is enabled, Starplot will log debugging information and plot polygons for debugging text issues"""
+
+
+settings = Settings()

starplot/coordinates.py

@@ -0,0 +1,7 @@
+class CoordinateSystem:
+    RA_DEC = "radec"
+    AZ_ALT = "azalt"
+    AXES = "axes"
+    PROJECTED = "projected"
+    DISPLAY = "display"
+    GALACTIC = "galactic"

starplot/data/__init__.py

@@ -0,0 +1,22 @@
+# ruff: noqa: F401,F403
+
+from pathlib import Path
+
+from skyfield.api import Loader
+
+from starplot.config import settings
+from .catalogs import Catalog
+
+load = Loader(settings.data_path)  # used for loading ephemeris
+
+
+HERE = Path(__file__).resolve().parent
+
+INTERNAL_DATA_PATH = HERE / "library"
+"""Path of starplot data"""
+
+
+class DataFiles:
+    STAR_DESIGNATIONS = INTERNAL_DATA_PATH / "star_designations.parquet"
+    CONSTELLATION_NAMES = INTERNAL_DATA_PATH / "constellation_names.parquet"
+    DSO_NAMES = INTERNAL_DATA_PATH / "dso_names.parquet"