starplot 0.20.5__py3-none-any.whl

starplot/styles/fonts-library/inter/LICENSE.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

starplot/styles/fonts.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+from matplotlib import font_manager
+
+HERE = Path(__file__).resolve().parent
+FONTS_PATH = HERE / "fonts-library"
+
+
+def load():
+    """Loads all fonts in ./fonts-library"""
+    font_dirs = [FONTS_PATH]
+    font_files = font_manager.findSystemFonts(fontpaths=font_dirs)
+
+    for font_file in font_files:
+        font_manager.fontManager.addfont(font_file)

starplot/styles/helpers.py

@@ -0,0 +1,93 @@
+import inspect
+import json
+
+from functools import wraps
+
+
+def merge_dict(dict_1: dict, dict_2: dict) -> None:
+    """
+
+    Args:
+        dict_1: Base dictionary to merge into
+        dict_2: Dictionary to merge into the base (dict_1)
+
+    Returns:
+        None (dict_1 is modified directly)
+    """
+    for k in dict_2.keys():
+        if k in dict_1 and isinstance(dict_1[k], dict) and isinstance(dict_2[k], dict):
+            merge_dict(dict_1[k], dict_2[k])
+        else:
+            dict_1[k] = dict_2[k]
+
+
+def use_style(style_class, style_attr: str = None):
+    def decorator(func):
+        params = list(inspect.signature(func).parameters.keys())
+        style_pos = params.index("style") if "style" in params else -1
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            style_in_positional = 0 <= style_pos < len(args)
+            style = args[style_pos] if style_in_positional else kwargs.get("style")
+            style_kwargs = {
+                kw: value for kw, value in kwargs.items() if kw.startswith("style__")
+            }
+
+            if style and style_kwargs:
+                raise ValueError(
+                    "Too many style arguments types. Specify only style or style kwargs"
+                )
+
+            if style and isinstance(style, dict):
+                if style_attr is not None:
+                    # if style is a dict and there's a base style, then we just want to merge the changes
+                    base_style = getattr(args[0].style, style_attr).model_dump_json()
+                    base_style = json.loads(base_style)
+
+                    merge_dict(base_style, style)
+
+                    kwargs["style"] = style_class(**base_style)
+                else:
+                    kwargs["style"] = style_class(**style)
+
+            elif style_kwargs:
+                # if style kwargs are used - build style dict and pass as "style" variable
+                styling_overrides = {}
+                for key, val in style_kwargs.items():
+                    t = styling_overrides
+                    prev = None
+                    for part in key.split("__")[1:]:
+                        if prev is not None:
+                            t = t.setdefault(prev, {})
+                        prev = part
+                    t.setdefault(prev, val)
+                if style_attr is not None:
+                    base_style = getattr(args[0].style, style_attr).model_dump_json()
+                    base_style = json.loads(base_style)
+
+                    merge_dict(base_style, styling_overrides)
+
+                    kwargs["style"] = style_class(**base_style)
+                else:
+                    kwargs["style"] = style_class(**styling_overrides)
+
+                # remove 'style__' kwargs so they're not passed to wrapped function
+                kwargs = {
+                    kw: value
+                    for kw, value in kwargs.items()
+                    if not kw.startswith("style__")
+                }
+
+            elif style is None and style_attr is not None:
+                # if no style overrides and there's a base style, then just pass the base style
+                kwargs["style"] = getattr(args[0].style, style_attr, None)
+
+            elif style is None and not style_in_positional:
+                kwargs["style"] = style_class()
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

starplot/styles/markers.py

@@ -0,0 +1,308 @@
+from functools import cache
+
+from matplotlib import transforms
+from matplotlib.path import Path
+
+import numpy as np
+
+
+def ellipse_points(
+    center_x, center_y, semi_major_axis, semi_minor_axis, num_points=100
+):
+    """Generates points on an ellipse.
+
+    Args:
+        center_x: X coordinate of the center.
+        center_y: Y coordinate of the center.
+        semi_major_axis: Length of the semi-major axis.
+        semi_minor_axis: Length of the semi-minor axis.
+        num_points: Number of points to generate.
+
+    Returns:
+        A list of (x, y) coordinates of the ellipse points.
+    """
+
+    theta = np.linspace(0, 2 * np.pi, num_points)
+    x = center_x + semi_major_axis * np.cos(theta)
+    y = center_y + semi_minor_axis * np.sin(theta)
+
+    return list(zip(x, y))
+
+
+@cache
+def ellipse():
+    verts = ellipse_points(0, 0, 1, 0.5)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+    p = Path(verts, codes).transformed(transforms.Affine2D().rotate_deg(15))
+
+    return p
+
+
+@cache
+def circle_cross():
+    verts = ellipse_points(0, 0, 1, 1)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    verts.extend(
+        [
+            (-1, 0),
+            (1, 0),
+            (0, 1),
+            (0, -1),
+        ]
+    )
+    codes.extend(
+        [
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+        ]
+    )
+
+    return Path(verts, codes)
+
+
+@cache
+def circle_crosshair():
+    verts = ellipse_points(0, 0, 1, 1)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    verts.extend(
+        [
+            (-1, 0),
+            (-1.7, 0),
+            (0, 1),
+            (0, 1.7),
+            (1, 0),
+            (1.7, 0),
+            (0, -1),
+            (0, -1.7),
+        ]
+    )
+    codes.extend(
+        [
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+        ]
+    )
+
+    return Path(verts, codes)
+
+
+@cache
+def circle_dot():
+    verts = ellipse_points(0, 0, 1, 1)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    verts.extend(ellipse_points(0, 0, 0.6, 0.6))
+
+    codes.extend([Path.MOVETO])
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    return Path(verts, codes)
+
+
+@cache
+def circle_dotted_rings(num_rings=2):
+    verts = ellipse_points(0, 0, 1, 1)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    step = 2
+    for n in range(num_rings):
+        radius = 1.4 + n * 0.3
+        ring_verts = ellipse_points(0, 0, radius, radius)
+
+        for k in range(step, 100, step):
+            if k % (step * 2):
+                verts.extend(ring_verts[k : k + step])
+                codes.extend([Path.MOVETO])
+                codes.extend([Path.LINETO] * (step - 1))
+
+    return Path(verts, codes)
+
+
+@cache
+def circle_line():
+    # verts = list(ellipse_points(0, 0, 1, 1))
+    # size = len(verts)
+    # top = verts[2 : int(size / 2 - 2)]
+    # bottom = verts[int(size / 2 + 2) : size - 2]
+    # y = top[-1][1]
+    # top = [[2, 0], [2, y]] + top + [[-2, top[-1][1]], [-2, 0]]
+    # bottom = [[-2, 0], [-2, -1 * y]] + bottom + [[2, -1 * y], [2, 0], [2, 0]]
+
+    points = [
+        [2, 0],
+        [2, 0.18925124436040974],
+        (0.9819286972627067, 0.18925124436041021),
+        (0.9679487013963562, 0.2511479871810792),
+        (0.9500711177409454, 0.3120334456984871),
+        (0.9283679330160726, 0.3716624556603276),
+        (0.9029265382866212, 0.42979491208917164),
+        (0.8738493770697849, 0.4861967361004687),
+        (0.8412535328311812, 0.5406408174555976),
+        (0.8052702575310586, 0.5929079290546404),
+        (0.766044443118978, 0.6427876096865393),
+        (0.7237340381050701, 0.690079011482112),
+        (0.6785094115571322, 0.7345917086575333),
+        (0.6305526670845225, 0.7761464642917568),
+        (0.5800569095711982, 0.8145759520503357),
+        (0.5272254676105024, 0.8497254299495144),
+        (0.4722710747726827, 0.8814533634475821),
+        (0.41541501300188644, 0.9096319953545183),
+        (0.3568862215918719, 0.9341478602651067),
+        (0.2969203753282749, 0.9549022414440739),
+        (0.23575893550942728, 0.9718115683235417),
+        (0.17364817766693041, 0.984807753012208),
+        (0.1108381999010111, 0.9938384644612541),
+        (0.04758191582374218, 0.998867339183008),
+        (-0.01586596383480803, 0.9998741276738751),
+        (-0.07924995685678854, 0.9968547759519424),
+        (-0.14231483827328523, 0.9898214418809327),
+        (-0.20480666806519074, 0.9788024462147787),
+        (-0.26647381369003503, 0.963842158559942),
+        (-0.32706796331742166, 0.9450008187146685),
+        (-0.3863451256931287, 0.9223542941045814),
+        (-0.4440666126057741, 0.8959937742913359),
+        (-0.5000000000000002, 0.8660254037844385),
+        (-0.5539200638661103, 0.8325698546347714),
+        (-0.6056096871376668, 0.795761840530832),
+        (-0.654860733945285, 0.7557495743542583),
+        (-0.7014748877063214, 0.7126941713788627),
+        (-0.7452644496757547, 0.6667690005162917),
+        (-0.7860530947427875, 0.6181589862206051),
+        (-0.8236765814298327, 0.5670598638627709),
+        (-0.8579834132349771, 0.5136773915734063),
+        (-0.8888354486549234, 0.4582265217274105),
+        (-0.9161084574320696, 0.4009305354066136),
+        (-0.9396926207859083, 0.3420201433256689),
+        (-0.9594929736144974, 0.28173255684142967),
+        (-0.975429786885407, 0.2511479871810792),
+        (-0.9874388886763943, 0.18925124436040974),
+        [-2, 0.18925124436040974],
+        [-2, 0],
+        [-2, 0],
+        [-2, -0.18925124436040974],
+        (-0.9874388886763943, -0.18925124436040974),
+        (-0.975429786885407, -0.2511479871810792),
+        (-0.9594929736144974, -0.28173255684142984),
+        (-0.9396926207859084, -0.34202014332566866),
+        (-0.9161084574320696, -0.4009305354066138),
+        (-0.8888354486549235, -0.4582265217274103),
+        (-0.857983413234977, -0.5136773915734064),
+        (-0.8236765814298328, -0.5670598638627706),
+        (-0.7860530947427874, -0.6181589862206053),
+        (-0.7452644496757548, -0.6667690005162915),
+        (-0.7014748877063213, -0.7126941713788629),
+        (-0.6548607339452852, -0.7557495743542582),
+        (-0.6056096871376666, -0.7957618405308321),
+        (-0.5539200638661105, -0.8325698546347713),
+        (-0.4999999999999996, -0.8660254037844388),
+        (-0.44406661260577396, -0.895993774291336),
+        (-0.3863451256931287, -0.9223542941045814),
+        (-0.3270679633174219, -0.9450008187146683),
+        (-0.26647381369003464, -0.9638421585599422),
+        (-0.20480666806519054, -0.9788024462147787),
+        (-0.14231483827328523, -0.9898214418809327),
+        (-0.07924995685678879, -0.9968547759519423),
+        (-0.01586596383480761, -0.9998741276738751),
+        (0.04758191582374238, -0.998867339183008),
+        (0.11083819990101086, -0.9938384644612541),
+        (0.17364817766692997, -0.9848077530122081),
+        (0.23575893550942748, -0.9718115683235417),
+        (0.2969203753282749, -0.9549022414440739),
+        (0.35688622159187167, -0.9341478602651068),
+        (0.4154150130018868, -0.9096319953545182),
+        (0.4722710747726829, -0.881453363447582),
+        (0.5272254676105024, -0.8497254299495144),
+        (0.5800569095711979, -0.8145759520503358),
+        (0.6305526670845228, -0.7761464642917566),
+        (0.6785094115571323, -0.7345917086575332),
+        (0.7237340381050701, -0.690079011482112),
+        (0.7660444431189778, -0.6427876096865396),
+        (0.8052702575310587, -0.5929079290546402),
+        (0.8412535328311812, -0.5406408174555974),
+        (0.8738493770697849, -0.4861967361004688),
+        (0.9029265382866211, -0.4297949120891719),
+        (0.9283679330160727, -0.37166245566032724),
+        (0.9500711177409454, -0.31203344569848707),
+        (0.9679487013963562, -0.2511479871810794),
+        (0.9819286972627068, -0.18925124436040974),
+        [2, -0.18925124436040974],
+        [2, 0],
+        [2, 0],
+    ]
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * (len(points) - 2))
+    codes.extend([Path.CLOSEPOLY])
+
+    return Path(points, codes)
+
+
+def circle_line_deprecated():
+    verts = ellipse_points(0, 0, 1, 1)
+
+    codes = [
+        Path.MOVETO,
+    ]
+    codes.extend([Path.LINETO] * 98)
+    codes.extend([Path.CLOSEPOLY])
+
+    verts.extend(
+        [
+            (-2, 0),
+            (2, 0),
+            (-2, 0.04),
+            (2, 0.04),
+            (-2, -0.04),
+            (2, -0.04),
+        ]
+    )
+    codes.extend(
+        [
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+            Path.MOVETO,
+            Path.LINETO,
+        ]
+    )
+
+    return Path(verts, codes)

starplot/utils.py

@@ -0,0 +1,169 @@
+import math
+from datetime import datetime, timezone
+
+import numpy as np
+
+
+def in_circle(x, y, center_x=0, center_y=0, radius=0.9) -> bool:
+    """Determine if a point (x,y) is inside a circle"""
+    return (x - center_x) ** 2 + (y - center_y) ** 2 < (radius**2)
+
+
+def lon_to_ra(lon: float):
+    pos_lon = lon + 180
+    ra = 12 - (24 * pos_lon / 360)
+    if ra < 0:
+        ra += 24
+    return ra
+
+
+def ra_to_lon(ra):
+    lon = ra * -15
+    if lon < -180:
+        lon += 360
+
+    return lon
+
+
+def lon_to_ra_hms(lon: float) -> (int, int, int):
+    """Converts longitude back to right ascension
+
+    Args:
+        lon: Longitude to convert
+
+    Returns:
+        Tuple of ints: (hours, minutes, seconds)
+    """
+    pos_lon = lon + 180
+    ra_decimal = 12 - (24 * pos_lon / 360)
+
+    hour = math.floor(ra_decimal)
+
+    min_decimal = 60 * (ra_decimal - hour)
+    minutes = math.floor(min_decimal)
+
+    sec_decimal = 60 * (min_decimal - minutes)
+    seconds = math.floor(sec_decimal)
+
+    if hour < 0:
+        hour += 24
+
+    if seconds >= 60:
+        minutes += 1
+        seconds -= 60
+
+    return hour, minutes, seconds
+
+
+def dec_str_to_float(dec_str):
+    """
+    Converts declination strings to a single float:
+
+    >> dec_str_to_float("-05:20:30")
+    >> -5.341667
+
+    """
+    multiplier = 1
+    dec_d, dec_m, dec_s = [float(d) for d in dec_str.split(":")]
+
+    if dec_str.startswith("-"):
+        multiplier = -1
+
+    dec_f = dec_d + multiplier * ((dec_m / 60) + (dec_s / 3600))
+
+    return round(dec_f, 6)
+
+
+def bv_to_hex_color(bv_index):
+    """
+    Returns hex color for a BV Index
+
+    List of BV colors from -0.40 -> 2.00 (with 0.05 increments)
+    source: http://www.vendian.org/mncharity/dir3/starcolor/details.html
+    """
+    bv_colors = [
+        "#9bb2ff",
+        "#9eb5ff",
+        "#a3b9ff",
+        "#aabfff",
+        "#b2c5ff",
+        "#bbccff",
+        "#c4d2ff",
+        "#ccd8ff",
+        "#d3ddff",
+        "#dae2ff",
+        "#dfe5ff",
+        "#e4e9ff",
+        "#e9ecff",
+        "#eeefff",
+        "#f3f2ff",
+        "#f8f6ff",
+        "#fef9ff",
+        "#fff9fb",
+        "#fff7f5",
+        "#fff5ef",
+        "#fff3ea",
+        "#fff1e5",
+        "#ffefe0",
+        "#ffeddb",
+        "#ffebd6",
+        "#ffe9d2",
+        "#ffe8ce",
+        "#ffe6ca",
+        "#ffe5c6",
+        "#ffe3c3",
+        "#ffe2bf",
+        "#ffe0bb",
+        "#ffdfb8",
+        "#ffddb4",
+        "#ffdbb0",
+        "#ffdaad",
+        "#ffd8a9",
+        "#ffd6a5",
+        "#ffd5a1",
+        "#ffd29c",
+        "#ffd096",
+        "#ffcc8f",
+        "#ffc885",
+        "#ffc178",
+        "#ffb765",
+        "#ffa94b",
+        "#ff9523",
+        "#ff7b00",
+        "#ff5200",
+    ]
+    color_index = round((bv_index + 0.4) / 0.05)
+
+    if color_index < 0 or color_index > len(bv_colors) - 1:
+        return None
+
+    return bv_colors[color_index]
+
+
+def azimuth_to_string(azimuth_degrees: int):
+    if azimuth_degrees >= 360:
+        azimuth_degrees -= 360
+    direction_strings = ["N", "NE", "E", "SE", "S", "SW", "W", "NW", "N"]
+    return direction_strings[int(azimuth_degrees / 40)]
+
+
+def dt_or_now(dt):
+    return dt or datetime.now(tz=timezone.utc)
+
+
+def points_on_line(start, end, num_points=100):
+    """Generates points along a line segment.
+
+    Args:
+        start (tuple): (x, y) coordinates of the starting point.
+        end (tuple): (x, y) coordinates of the ending point.
+        num_points (int): Number of points to generate.
+
+    Returns:
+        list: List of (x, y) coordinates of the generated points.
+    """
+
+    x_coords = np.linspace(start[0], end[0], num_points)
+    y_coords = np.linspace(start[1], end[1], num_points)
+
+    return list(zip(x_coords, y_coords))

starplot/warnings.py

@@ -0,0 +1,21 @@
+import warnings
+
+import matplotlib
+
+
+def suppress():
+    # ignore noisy matplotlib warnings
+    warnings.filterwarnings(
+        "ignore",
+        message="Setting the 'color' property will override the edgecolor or facecolor properties",
+    )
+
+    # Silence various matplotlib logs (e.g. building font cache)
+    matplotlib.set_loglevel("critical")
+
+    # Silence all user warnings
+    warnings.filterwarnings("ignore", category=UserWarning)
+
+    # Silence noisy cartopy warnings
+    warnings.filterwarnings("ignore", module="cartopy")
+    warnings.filterwarnings("ignore", module="shapely")