astrolabium 0.1.0__tar.gz

astrolabium-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vindemiatrix Collective
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

astrolabium-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.3
+Name: astrolabium
+Version: 0.1.0
+Summary: Stellar catalogue parser and creator
+License: MIT
+Keywords: astronomy,cosmology,space,science,stars,star,double,binary
+Author: Vindemiatrix Collective
+Author-email: vindemiatrixcollective@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: SPARQLWrapper
+Requires-Dist: anytree
+Requires-Dist: astropy
+Requires-Dist: astroquery
+Requires-Dist: tqdm

astrolabium-0.1.0/astrolabium/__init__.py

@@ -0,0 +1,3 @@
+import astrolabium.config
+import astrolabium.fileIO
+import astrolabium.table as Table

astrolabium-0.1.0/astrolabium/config.py

@@ -0,0 +1,5 @@
+path_outdir = "out"
+path_temp = "temp"
+path_cataloguedir = "catalogues"
+path_datadir = "data"
+path_entitiesdir = "entities"

astrolabium-0.1.0/astrolabium/converters/__init__.py

@@ -0,0 +1,2 @@
+from .hip import *
+from ..creator.star import Star

astrolabium-0.1.0/astrolabium/converters/iau.py

@@ -0,0 +1,186 @@
+import astrolabium.config as config
+import astrolabium.queries.wikidata as wiki
+import astrolabium.queries.simbad as simbad
+import astrolabium.fileIO as io
+import time
+import json
+import unicodedata
+from tqdm import tqdm
+
+__missing_ids = {"TrES-3": "Q1107722"}
+__missing_names = {""}
+# __iau_data = io.read_dict_json(f"{config.path_cataloguedir}/IAU-CSN")
+
+
+def find_catalogue_ids(n=0):
+    starDict = dict()
+    jsonData = io.read_dict_json(f"{config.path_cataloguedir}/IAU-CSN")
+    if n == 0:
+        n = len(jsonData)
+    for i, entry in enumerate(jsonData[:n]):
+        name = entry["Name"]
+        hip = entry["HIP"]
+        if hip != "_":
+            print(f"[{i + 1}/{n}] Parsing {name}")
+            starDict[name] = hip
+        else:
+            print(f"[{i + 1}/{n}] No HIP for {name}")
+
+    return starDict
+
+
+def find_entries_without_catalogue_ids(catalog="HIP"):
+    starDict = dict()
+    n = len(__iau_data)
+    counter = 1
+    for i, entry in enumerate(__iau_data[:n]):
+        hip = entry[catalog]
+        if hip != "_":
+            continue
+        label = entry["Designation"]
+        print(f"[{counter}/{i + 1}]: {label}")
+        counter += 1
+        starDict[label] = entry
+    qid_list = []
+
+    for key, value in tqdm(starDict.items(), colour="GREEN"):
+        name = value["Name"]
+        qid = __parse_entities(key, name)
+        if qid is not None:
+            qid_list.append(qid)
+        else:
+            if key in __missing_ids:
+                qid = __missing_ids[key]
+            else:
+                qid = __parse_entities(key, name, False)
+
+            if qid is not None:
+                qid_list.append(qid)
+            else:
+                tqdm.write(f">>> Cannot find {key}: {name}")
+        time.sleep(0.250)
+    return qid_list
+
+
+def __parse_entities(key: str, name: str, use_key=True):
+    starFound = False
+    try:
+        for entity in wiki.get_entity_from_name(key if use_key else name):
+            qid = entity["id"]
+            starFound = __is_entity_star(entity, key, name, qid)
+            if starFound:
+                return qid
+        if not starFound:
+            return None
+    except TypeError as e:
+        return None
+
+
+def __is_entity_star(entity, key, name, qid):
+    if "description" not in entity:
+        tqdm.write(f"Looking for <{key}/{name}> cannot parse qid:{qid}")
+        return False
+    desc = entity["description"].lower()
+    tokens = ["star", "gamma ray", "pulsar"]
+    if any(x in desc for x in tokens):
+        tqdm.write(f"Looking for <{key}/{name}>, found qid: {qid} is a star")
+        return True
+    else:
+        return False
+
+
+def iau_to_wiki(out_filename=f"{config.path_outdir}/IAU-CSN"):
+    iau_ids = find_catalogue_ids()
+    print("\nRequesting qids from Wikidata\n...")
+    iau_in_cat = wiki.get_qids_from_catalogue_entries("Q537199", "HIP", iau_ids.values())
+    iau_not_cat = find_entries_without_catalogue_ids()
+    iau_qids = [item["qid"] for item in iau_in_cat] + iau_not_cat
+    n = len(iau_qids)
+    print(f"   > Found {len(iau_in_cat) + len(iau_not_cat)} / {n} matching entities")
+
+    iau_entries = wiki.get_entities_batch(iau_qids, batch_size=50)
+
+    io.write_dict_json(iau_entries, out_filename)
+    print(f"\n{n} Wikidata entities written to {config.path_outdir}/{out_filename}.json")
+
+
+def normalise_names(filename=f"{config.path_outdir}/IAU-CSN"):
+    print("Normalising names in IAU entities")
+    name_key = "Name/Diacritics"
+    iau_entities = io.read_dict_json(filename)
+    for i, (key, value) in tqdm(enumerate(iau_entities.items())):
+        if "name" in value:
+            name = value["name"]
+            using_name = True
+        else:
+            name = value["id"]
+            using_name = False
+
+        catalogue_id = value["cat"]["hip"] if "hip" in value["cat"] else list(value["cat"])[0]
+        catalogue_id = (
+            catalogue_id.split(" ")[1] if catalogue_id.startswith("HIP") or catalogue_id.startswith("HD") else None
+        )
+
+        iau_match = [star for star in __iau_data if star[name_key] == name]
+        if len(iau_match) > 0:
+            value["name"] = name
+            tqdm.write(f"{key}: {name} matches")
+            continue
+        else:
+            if using_name:
+                iau_match = [star for star in __iau_data if star[name_key] == value["id"]]
+                if len(iau_match) > 0:
+                    value["name"] = value["id"]
+                    tqdm.write(f"{key}: {value['id']} matches")
+                    continue
+
+        if catalogue_id is not None:
+            iau_match = [star for star in __iau_data if star["HIP"] == catalogue_id or star["HD"] == catalogue_id]
+            if len(iau_match) > 0:
+                iau_name = iau_match[0][name_key]
+                tqdm.write(f">>> {key}: {name} does not match with {iau_name}, using IAU name")
+                value["name"] = iau_name
+                continue
+
+        iau_match = [star for star in __iau_data if star["Designation"] == name]
+        if len(iau_match) > 0:
+            iau_name = iau_match[0][name_key]
+            tqdm.write(f">>> {key}: {name} does not match with {iau_name}, using IAU name")
+            value["name"] = iau_name
+            continue
+
+        tqdm.write(f">>> {key}: {name} no name found")
+        raise
+    io.write_dict_json(iau_entities, filename)
+    print("All stars matched!")
+
+
+def add_simbad_otypes(filename=f"{config.path_outdir}/IAU-CSN"):
+    print("Adding otypes from Simbad")
+    iau_entities = io.read_dict_json(filename)
+
+    iau_ids = []
+    iau_map = {}
+    valid_cat = ["hip", "tyc", "gaia_dr3", "PSR"]
+    for i, (key, entity) in enumerate(iau_entities.items()):
+        catalog = entity["cat"]
+        iau_id = None
+        for cat_type in list(catalog.items()):
+            if cat_type[0] in valid_cat:
+                iau_id = f"{cat_type[0].upper().replace('_', ' ')} {cat_type[1]}"
+                iau_map[key] = iau_id
+                iau_ids.append(iau_id)
+                break
+
+        if iau_id is None:
+            raise ValueError(f"Catalog ids for {key}: {catalog}")
+
+    results = simbad.get_object_ids(iau_ids)
+    for result in tqdm(results):
+        iau_map[result["id"]] = result["otypes"]
+        tqdm.write(json.dumps(result))
+
+    res_ids = [x["id"] for x in results]
+    diff = set(iau_ids) - set(res_ids)
+    print(diff)
+    io.write_list_json(diff, filename + "_missing_simbad_otype")

astrolabium-0.1.0/astrolabium/creator/__init__.py

@@ -0,0 +1,5 @@
+from .star import Star
+from .system import System
+from .galaxy import Galaxy
+from .wds_analyser import WDSAnalyser
+from .catalogue_creator import CatalogueCreator

astrolabium-0.1.0/astrolabium/creator/catalogue_creator.py

@@ -0,0 +1,173 @@
+from astrolabium import fileIO as io, config
+from astrolabium.parsers import HipparcosParser, WDSParser, Orb6Parser
+from astrolabium.parsers.data import WikidataStar, Text
+from astrolabium.catalogues import Hipparcos, WDS, Crossref, filters
+from astrolabium.queries import WikiEntities, gaia
+from astrolabium.creator import WDSAnalyser, Star, System, Galaxy
+import logging
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+class CatalogueCreator:
+    def __init__(
+        self,
+        lyr=100,
+        catalogue_path=f"{config.path_datadir}/hipparcos2007",
+        entities_path=f"{config.path_entitiesdir}/hipparcos2007_entities",
+        verbose=False,
+    ):
+        self.verbose = verbose
+        self.lyr = lyr
+        self.catalogue_path = catalogue_path
+        self.entities_path = entities_path
+        self.iau_entities_path = f"{config.path_entitiesdir}/IAU_entities"
+        self.output_catalogue_path = f"{config.path_outdir}/catalogue_{self.lyr}_ly"
+        self._use_entities = True
+        logging.basicConfig(format="%(message)s")
+        logging.root.setLevel(logging.INFO)
+        logger.info("Astrolabium v0.1.0 by Vindemiatrix Collective (https://vindemiatrixcollective.com)\n")
+        io.create_directory(config.path_entitiesdir)
+        io.create_directory(config.path_datadir)
+        io.create_directory(config.path_temp)
+        io.create_directory(config.path_outdir)
+        if (not io.file_exists(entities_path)):
+            self._use_entities = False
+        pass
+    
+    @classmethod
+    def download_and_parse_catalogues(cls):
+        io.create_directory(config.path_cataloguedir)
+        stars = HipparcosParser.run()
+        WDSParser.run()
+        Orb6Parser.run()
+        hip = Hipparcos(catalogue_data=stars)
+        Crossref.build_table("HIP", [str(x.HIP) for x in hip.entries], Crossref.catalogue_labels, save=True)
+
+    def find_star_systems(self, crossref_filters: list[Callable] = None, rebuild=False) -> list[System]:
+        hip_stars_path = f"{config.path_temp}/catalogue_stars_{self.lyr}_ly"
+        systems_within_distance = io.read_list_json(hip_stars_path)
+        if systems_within_distance is None or len(systems_within_distance) == 0 or rebuild:
+            logger.info(f"Filtering star systems within {self.lyr} ly")
+
+            if crossref_filters is None:
+                crossref_filters = [
+                    lambda star: filters.distance(star, self.lyr),
+                    lambda star: filters.any_catalogues(star, ["b", "fl", "Name"]),
+                ]
+            crossref = Crossref()
+            hipparcos = Hipparcos()
+            systems_within_distance = crossref.query_filters(hipparcos.entries, "HIP", crossref_filters, hip_stars_path)
+
+        if systems_within_distance is None or len(systems_within_distance) == 0:
+            raise ValueError("No single stars found: are the filters too stringent?")
+
+        logger.info(f"Found {len(systems_within_distance)} / {Hipparcos.num_entries()} stars within {self.lyr} lyr")
+
+        systems = []
+        for entry in systems_within_distance:
+            if "WDS" in entry:
+                continue
+            star = Star(catalogue_entry=entry, crossref=entry)
+            name = Text.classic_system_name(entry)
+            systems.append(System(name, star))
+
+        logger.info(f"   of which {len(systems)} are single star systems")
+        logger.info(f"   and {len(systems_within_distance) - len(systems)} are potential multiple star systems")
+
+        return systems
+
+    def find_multiple_systems(self, rebuild=False):
+        wds_stars_path = f"{config.path_temp}/wds_stars_{self.lyr}_ly"
+        mult_systems = io.read_list_json(wds_stars_path)
+
+        if mult_systems is None or len(mult_systems) == 0 or rebuild:
+            hipparcos = Hipparcos()
+            wds = WDS()
+            query_filters = [
+                lambda star: filters.distance(star, self.lyr),
+                lambda star: filters.any_catalogues(star, ["WDS"]),
+                lambda star: filters.any_catalogues(star, ["b", "fl", "Name"]),
+                lambda star: filters.wds_is_physical(star, wds),
+            ]
+            crossref = Crossref()
+            mult_systems = crossref.query_filters(hipparcos.entries, "HIP", query_filters, wds_stars_path)
+
+        if mult_systems is None or len(mult_systems) == 0:
+            raise ValueError("No multiple stars found: are the filters too stringent?")
+        logger.info("Analysing multiple star systems")
+        analysis = WDSAnalyser(crossref_data=mult_systems, verbose=self.verbose)
+
+        systems = analysis.analyse()
+        return systems
+
+    def __match_systems_to_entities(self, systems: list[System], save=True):
+        entities_path = f"{config.path_temp}/catalogue_{self.lyr}_ly_entities"
+        wiki_entities = io.read_dict_json(entities_path)
+
+        catalogue_ids = []
+        for system in systems:
+            catalogue_ids += system.orbiters_catalogue_ids
+
+        if not wiki_entities:
+            wiki_entities = io.read_dict_json(self.entities_path)
+            if not wiki_entities:
+                logger.warning("Wikidata entity file not available, retrieving from wikidata")
+                wiki_entities = WikiEntities.retrieve_entities_from_file(catalogue_ids, self.entities_path)
+            wikiCatalog = WikiEntities(wiki_entities)
+            wikiCatalog.filter(lambda e: f"HIP {e.cat['hip']}" in catalogue_ids, "> Selecting stars in Hipparcos 2007 catalogue")
+            if save:
+                wikiCatalog.save(entities_path)
+        else:
+            wikiCatalog = WikiEntities(wiki_entities)
+
+        wikiCatalog.add(self.get_stars_from_IAU())
+        logger.info(f"> HIP: found {wikiCatalog.count} wikidata entities within {self.lyr} lyr distance")
+        wikiCatalog.build_index("HIP")
+
+        for system in systems:
+            for star in system.preorder_visit():
+                entity = wikiCatalog.query(star.id)
+                if entity is not None:
+                    star.add_properties(entity)
+
+    def update_names_from_IAU(self, table, namekey="Name"):
+        # TODO: ensure IAU names overwrite names we might get from other sources
+        raise NotImplementedError("Todo")
+        iau_data = io.read_list_json(f"{config.path_datadir}/IAU-CSN.json")
+
+    def get_stars_from_IAU(self) -> list[WikidataStar]:
+        iau = WikiEntities(io.read_dict_json(self.iau_entities_path))
+
+        iau.filter(
+            lambda e: "hip" not in e.cat,
+            "> Adding missing star from IAU",
+        )
+        iau.filter(lambda e: WikiEntities.filter_distance(e, self.lyr), f"> Removing stars farther than {self.lyr} ly")
+        logger.warning(f"> Found {iau.count} stars missing from HIP catalogue")
+        return iau.values
+
+    def update_from_gaia(self, stars: dict[str, "Star"]):
+        stars_dr3 = {star.dr3: star for key, star in stars.items() if hasattr(star, "dr3")}
+        source_ids = list(stars_dr3.keys())
+        if len(source_ids) == 0:
+            source_ids = [2067518817314952576, 3211922645854328832, 66529975427235712]
+        data = gaia.retrieve_data(source_ids)
+        gaia.update_data(stars_dr3, data)
+
+    def create_galaxy(self, rebuild=False, match_to_wikidata_entities=True, save=True):
+        single_stars = self.find_star_systems(rebuild=rebuild)
+        multiple_stars = self.find_multiple_systems(rebuild=rebuild)
+        total_systems = single_stars + multiple_stars
+
+        if not self._use_entities and match_to_wikidata_entities:
+            logger.warning("No Wikidata entities file found. Download it from the github and place it in your entities/ folder.")
+        elif match_to_wikidata_entities:
+            self.__match_systems_to_entities(total_systems)
+        
+        logger.info("Catalogue creation complete")
+        galaxy = Galaxy(total_systems)
+        if save:
+            galaxy.save(self.output_catalogue_path)
+            logger.info(f"Saved to {self.output_catalogue_path}")
+        return galaxy

astrolabium-0.1.0/astrolabium/creator/galaxy.py

@@ -0,0 +1,32 @@
+from astrolabium.creator import System, Star
+from astrolabium import fileIO as io
+import json
+from typing import Any
+
+
+class Galaxy:
+    def __init__(self, systems: list[System]):
+        self.Name = "Milky Way"
+        self.systems: dict[str, System] = {}
+
+        for system in systems:
+            self.systems[system.Name] = system
+        pass
+
+    @property
+    def count(self) -> int:
+        return len(self.systems)
+
+    def save(self, out_filename: str):
+        json_galaxy = {}
+
+        json_galaxy["Name"] = self.Name
+        json_galaxy["Systems"] = {name: system.to_dict() for name, system in self.systems.items()}
+
+        io.write_text_json(json.dumps(json_galaxy, indent=2), out_filename)
+
+    def add_systems(self, systems: list[System]):
+        self.systems = self.systems | {system.Name: system for system in systems}
+
+    def select(self, system_name: str) -> System | None:
+        return self.systems.get(system_name)

astrolabium-0.1.0/astrolabium/creator/star.py

@@ -0,0 +1,129 @@
+from astrolabium.parsers.data import EntryBase, HipparcosEntry, Orb6Entry, WikidataStar
+from astropy import units as u
+from astropy.coordinates import SkyCoord, ICRS, Galactic
+from tqdm import tqdm
+from typing import Any, Tuple
+import math
+
+
+class Star(EntryBase):
+    key_settings = [
+        ["id", [], None, None, None],
+        ["Name", [], None, None, None],
+        ["ra", [], lambda v: float(v), u.rad, 6],
+        ["dec", [], lambda v: float(v), u.rad, 6],
+        ["sc", [], None, None, None],
+        ["d", [], lambda v: float(v), u.pc, 6],
+        ["a", [], lambda v: float(v), u.AU, 6],
+        ["e", [], lambda v: float(v), None, 3],
+        ["P", [], lambda v: float(v), u.yr, 3],
+        ["i", [], lambda v: float(v), u.deg, 3],
+        ["lan", [], lambda v: float(v), u.deg, 3],
+        ["argp", [], lambda v: float(v), u.deg, 3],
+    ]
+
+    def __init__(self, catalogue_entry: EntryBase | None = None, orbit: Orb6Entry | None = None, crossref: Any | None = None):
+        self.id: str | None = None
+        self.Name: str | None = None
+        self.a: u.Quantity | None = None
+        self.d: u.Quantity | None = None
+        self.sc: str | None = None
+        self.Orbiters: dict[str, Star | None] = {}
+
+        data = {}
+        if orbit is not None and isinstance(orbit, Orb6Entry):
+            data = orbit.to_dict()
+            data["a"] = orbit.calculate_sma_AU(catalogue_entry.d)
+            # assuming lpa (Longitude of the Periastron ϖ) refers to the argument of the periastron instead (ω)
+            data["argp"] = data["lpa"]
+            del data["lpa"]
+
+        if crossref is not None:
+            data = data | crossref
+            if "st" in crossref and crossref["st"] != "":
+                data["sc"] = crossref["st"]
+            if catalogue_entry is None and "Name" in crossref:
+                del data["Name"]
+
+        if catalogue_entry is not None:
+            if not isinstance(catalogue_entry, HipparcosEntry):
+                catalogue_entry = HipparcosEntry(catalogue_entry)
+            data = data | catalogue_entry.to_dict()
+            data["id"] = catalogue_entry.id
+            # renaming de_clination to dec_lination
+            data["dec"] = data["de"]
+            data["d"] = catalogue_entry.d
+
+        self._parse_values(self.key_settings, data)
+
+    def to_dict(self):
+        json = {}
+        json["Id"] = self.extract_value("id", None, None)
+        json["Name"] = self.extract_value("Name", None, None)
+        json["SC"] = self.extract_value("sc", None, None)
+
+        physicalData = {
+            "l": self.extract_value("l", 6, u.L_sun),
+            "m": self.extract_value("m", 6, u.M_sun),
+            "t": self.extract_value("t", 6, u.K),
+            "g": self.extract_value("g", 6, u.Unit("cm/s**2")),
+            "age": self.extract_value("age", 6, u.Gyr),
+        }
+        json["PhysicalData"] = {k: v for k, v in physicalData.items() if v}
+
+        orbitalData = {
+            "a": self.extract_value("a", 6, u.AU),
+            "P": self.extract_value("P", 6, u.yr),
+            "e": self.extract_value("e", 6, None),
+            "i": self.extract_value("i", 3, u.deg),
+            "lan": self.extract_value("lan", 3, u.deg),
+            "argp": self.extract_value("argp", 3, u.deg),
+        }
+        json["OrbitalData"] = {k: v for k, v in orbitalData.items() if v}
+
+        orbiters = {}
+        for key, star in self.Orbiters.items():
+            if star is not None:
+                orbiters[key] = star.to_dict()
+
+        json["Orbiters"] = orbiters
+
+        return {k: v for k, v in json.items() if v}
+
+    def add_properties(self, data: WikidataStar, properties: list[str] = ["l", "m", "t", "g", "age"]):
+        for prop in properties:
+            value = getattr(data, prop, None)
+            if value is not None:
+                setattr(self, prop, value)
+
+    def to_string(self, indent_spaces=3):
+        (x, y, z) = self.xyz
+        string = super().to_string(indent_spaces)
+        string += f"{self._get_indent(indent_spaces)}x, y, z: {x}, {y}, {z}"
+        return string
+
+    @property
+    def gc(self):
+        assert hasattr(self, "ra"), "Missing ra"
+        assert hasattr(self, "dec"), "Missing dec"
+        gc = SkyCoord(ra=self.ra, dec=self.dec, distance=self.d if self.d > 0 else None, frame=ICRS)
+        return gc.transform_to(Galactic)
+
+    @property
+    def xyz(self) -> tuple[float, float, float]:
+        assert self.d is not None, f"{self.id}: missing distance"
+        gc = self.gc
+        l = gc.l.to(u.rad)
+        b = gc.b.to(u.rad)
+        d = self.d.to(u.pc)
+        x = d.value * math.cos(b.value) * math.cos(l.value)
+        y = d.value * math.cos(b.value) * math.sin(l.value)
+        z = d.value * math.sin(b.value)
+        return (x, y, z)
+
+    @classmethod
+    def preorder_visit(cls, star: "Star"):
+        yield star
+        for orbiter in star.Orbiters.values():
+            if orbiter is not None:
+                yield from Star.preorder_visit(orbiter)

astrolabium-0.1.0/astrolabium/creator/system.py

@@ -0,0 +1,64 @@
+from typing import Any
+from astrolabium.creator import Star
+import astropy.units as u
+
+
+class System:
+    def __init__(self, name: str, primary: Star = None):
+        self.Name = name
+        self.Orbiters: dict[str, Star] = {}
+        if primary is not None:
+            self.Orbiters["A"] = primary
+        self.gc: str | None = None
+
+    @property
+    def primary(self) -> Star:
+        return self.Orbiters["A"]
+
+    @property
+    def coordinates(self) -> str:
+        return self.__coord
+
+    @coordinates.setter
+    def coordinates(self, value: str):
+        self.__coord = value
+
+    def to_dict(self) -> dict:
+        json: dict[str, Any] = {}
+        json["Name"] = self.Name
+
+        x, y, z = self.primary.xyz
+        self.gc = f"{round(float(x), 6)}, {round(float(y), 6)}, {round(float(z), 6)}"
+
+        orbiters = {}
+
+        for key, star in self.Orbiters.items():
+            orbiters[key] = star.to_dict()
+
+        json["Orbiters"] = orbiters
+        json["c"] = self.gc
+
+        return json
+
+    def __iter__(self):
+        return self
+
+    def preorder_visit(self):
+        for star in self.Orbiters.values():
+            if star is not None:
+                yield from Star.preorder_visit(star)
+
+    @property
+    def orbiters_catalogue_ids(self) -> list[str]:
+        ids = []
+        for star in self.preorder_visit():
+            if star.id is not None:
+                ids.append(star.id)
+        return ids
+
+    @property
+    def stars(self) -> list[Star]:
+        stars = []
+        for star in self.preorder_visit():
+            stars.append(star)
+        return stars