#414: remove come more methods (#415)

* remove aggregate method

* remove save_data method

* remove_from custom

* remove helpers

* remove couple more methods

Author: Kraysent

app/data/model/__init__.py

@@ -1,11 +1,6 @@
 from app.data.model.bibliography import Bibliography
 from app.data.model.designation import DesignationCatalogObject
-from app.data.model.helpers import (
-    CatalogObjectEncoder,
-    Layer0CatalogObjectDecoder,
-    get_catalog_object_type,
-    new_catalog_object,
-)
+from app.data.model.helpers import get_catalog_object_type
 from app.data.model.icrs import ICRSCatalogObject
 from app.data.model.interface import CatalogObject, MeasuredValue, RawCatalog, get_object
 from app.data.model.layer2 import Layer2CatalogObject, Layer2Object
@@ -50,14 +45,11 @@
     "TableRecord",
     "RawCatalog",
     "CatalogObject",
-    "CatalogObjectEncoder",
-    "Layer0CatalogObjectDecoder",
     "DesignationCatalogObject",
     "ICRSCatalogObject",
     "RedshiftCatalogObject",
     "NatureCatalogObject",
     "get_catalog_object_type",
-    "new_catalog_object",
     "MeasuredValue",
     "Bibliography",
 ]

app/data/model/designation.py

@@ -14,31 +14,6 @@ def __eq__(self, value: object) -> bool:
 
         return self.designation == value.designation
 
-    @classmethod
-    def from_custom(cls, design: Any) -> Self:
-        return cls(str(design))
-
-    def layer0_data(self) -> dict[str, Any]:
-        return {"design": self.designation}
-
-    @classmethod
-    def aggregate(cls, objects: list[Self]) -> Self:
-        """
-        Aggregate designation is selected as the most common designation among all objects.
-        """
-        name_counts = {}
-
-        for obj in objects:
-            name_counts[obj.designation] = name_counts.get(obj.designation, 0) + 1
-
-        max_name = ""
-
-        for name, count in name_counts.items():
-            if count > name_counts.get(max_name, 0):
-                max_name = name
-
-        return cls(max_name)
-
     def catalog(self) -> interface.RawCatalog:
         return interface.RawCatalog.DESIGNATION
 
@@ -50,9 +25,6 @@ def layer1_table(cls) -> str:
     def layer1_keys(cls) -> list[str]:
         return ["design"]
 
-    def layer1_data(self) -> dict[str, Any]:
-        return {"design": self.designation}
-
     @classmethod
     def from_layer1(cls, data: dict[str, Any]) -> Self:
         return cls(design=data["design"])

app/data/model/helpers.py

@@ -1,32 +1,6 @@
-import json
-
 from app.data.model import designation, icrs, interface, nature, redshift
 
 
-class CatalogObjectEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if not isinstance(obj, interface.CatalogObject):
-            return json.JSONEncoder.default(self, obj)
-
-        data = obj.layer0_data()
-        data["catalog"] = obj.catalog().value
-
-        return data
-
-
-class Layer0CatalogObjectDecoder(json.JSONDecoder):
-    def __init__(self, *args, **kwargs):
-        super().__init__(object_hook=self.object_hook, **kwargs)
-
-    def object_hook(self, obj):
-        if "catalog" not in obj:
-            return obj
-
-        catalog = interface.RawCatalog(obj.pop("catalog"))
-
-        return new_catalog_object(catalog, **obj)
-
-
 def get_catalog_object_type(catalog: interface.RawCatalog) -> type[interface.CatalogObject]:
     if catalog == interface.RawCatalog.DESIGNATION:
         return designation.DesignationCatalogObject
@@ -38,7 +12,3 @@ def get_catalog_object_type(catalog: interface.RawCatalog) -> type[interface.Cat
         return nature.NatureCatalogObject
 
     raise ValueError(f"Unknown catalog: {catalog}")
-
-
-def new_catalog_object(catalog: interface.RawCatalog, **kwargs) -> interface.CatalogObject:
-    return get_catalog_object_type(catalog)(**kwargs)

app/data/model/icrs.py

@@ -1,10 +1,6 @@
 from typing import Any, Self, final
 
-from astropy import coordinates
-from astropy import units as u
-
 from app.data.model import interface
-from app.lib import astronomy
 
 
 @final
@@ -21,82 +17,15 @@ def __init__(
         self.e_ra = e_ra
         self.e_dec = e_dec
 
-    @classmethod
-    def from_custom(
-        cls,
-        ra: u.Quantity,
-        dec: u.Quantity,
-        e_ra: u.Quantity | None = None,
-        e_dec: u.Quantity | None = None,
-    ) -> Self:
-        if not interface.is_nan(ra) and not interface.is_nan(dec):
-            if ra.unit is not None:
-                ra_angle = coordinates.Angle(ra, unit=ra.unit)
-            else:
-                ra_angle = coordinates.Angle(ra)
-
-            if dec.unit is not None:
-                dec_angle = coordinates.Angle(dec, unit=dec.unit)
-            else:
-                dec_angle = coordinates.Angle(dec)
-        else:
-            raise ValueError("no ra or dec values")
-
-        if e_ra is None or e_dec is None:
-            raise ValueError("no e_ra or e_dec specified")
-
-        coords = coordinates.ICRS(ra=ra_angle, dec=dec_angle)
-
-        return cls(
-            astronomy.to(coords.ra, "deg"),
-            astronomy.to(coords.dec, "deg"),
-            astronomy.to(e_ra, "deg"),
-            astronomy.to(e_dec, "deg"),
-        )
-
-    def layer0_data(self) -> dict[str, Any]:
-        return {
-            "ra": self.ra,
-            "dec": self.dec,
-            "e_ra": self.e_ra,
-            "e_dec": self.e_dec,
-        }
-
     def __eq__(self, value: object) -> bool:
         if not isinstance(value, ICRSCatalogObject):
             return False
 
         return self.ra == value.ra and self.e_ra == value.e_ra and self.dec == value.dec and self.e_dec == value.e_dec
 
-    @classmethod
-    def aggregate(cls, objects: list[Self]) -> Self:
-        """
-        Aggregate coordinates are computed as the mean of all coordinates.
-        Errors are computed as the mean of all errors.
-        """
-        ras = [obj.ra for obj in objects]
-        e_ras = [obj.e_ra for obj in objects]
-        decs = [obj.dec for obj in objects]
-        e_decs = [obj.e_dec for obj in objects]
-
-        ra = sum(ras) / len(ras)
-        e_ra = sum(e_ras) / len(e_ras)
-        dec = sum(decs) / len(decs)
-        e_dec = sum(e_decs) / len(e_decs)
-
-        return cls(ra, dec, e_ra, e_dec)
-
     def catalog(self) -> interface.RawCatalog:
         return interface.RawCatalog.ICRS
 
-    def layer1_data(self) -> dict[str, Any]:
-        return {
-            "ra": self.ra,
-            "dec": self.dec,
-            "e_ra": self.e_ra,
-            "e_dec": self.e_dec,
-        }
-
     @classmethod
     def layer1_table(cls) -> str:
         return "icrs.data"

app/data/model/interface.py

@@ -41,24 +41,10 @@ class CatalogObject(abc.ABC):
     Represents an object stored in a particular catalog.
     """
 
-    @classmethod
-    @abc.abstractmethod
-    def aggregate(cls, objects: list[Self]) -> Self:
-        pass
-
     @abc.abstractmethod
     def catalog(self) -> RawCatalog:
         pass
 
-    @abc.abstractmethod
-    def layer0_data(self) -> dict[str, Any]:
-        pass
-
-    @classmethod
-    @abc.abstractmethod
-    def from_custom(cls, **kwargs) -> Self:
-        pass
-
     @classmethod
     @abc.abstractmethod
     def layer1_table(cls) -> str:
@@ -69,10 +55,6 @@ def layer1_table(cls) -> str:
     def layer1_keys(cls) -> list[str]:
         pass
 
-    @abc.abstractmethod
-    def layer1_data(self) -> dict[str, Any]:
-        pass
-
     @classmethod
     @abc.abstractmethod
     def from_layer1(cls, data: dict[str, Any]) -> Self:

app/data/model/nature.py

@@ -14,26 +14,6 @@ def __eq__(self, value: object) -> bool:
 
         return self.type_name == value.type_name
 
-    @classmethod
-    def from_custom(cls, type_name: Any) -> Self:
-        return cls(str(type_name))
-
-    def layer0_data(self) -> dict[str, Any]:
-        return {"type_name": self.type_name}
-
-    @classmethod
-    def aggregate(cls, objects: list[Self]) -> Self:
-        type_counts: dict[str, int] = {}
-        for obj in objects:
-            type_counts[obj.type_name] = type_counts.get(obj.type_name, 0) + 1
-
-        max_type = ""
-        for name, count in type_counts.items():
-            if count > type_counts.get(max_type, 0):
-                max_type = name
-
-        return cls(max_type)
-
     def catalog(self) -> interface.RawCatalog:
         return interface.RawCatalog.NATURE
 
@@ -45,9 +25,6 @@ def layer1_table(cls) -> str:
     def layer1_keys(cls) -> list[str]:
         return ["type_name"]
 
-    def layer1_data(self) -> dict[str, Any]:
-        return {"type_name": self.type_name}
-
     @classmethod
     def from_layer1(cls, data: dict[str, Any]) -> Self:
         return cls(type_name=data["type_name"])

app/data/model/redshift.py

@@ -1,9 +1,6 @@
 from typing import Any, Self, final
 
-from astropy import units as u
-
 from app.data.model import interface
-from app.lib import astronomy
 
 
 @final
@@ -16,42 +13,6 @@ def __init__(
         self.cz = cz
         self.e_cz = e_cz
 
-    @classmethod
-    def from_custom(
-        cls,
-        cz: u.Quantity | None = None,
-        z: float | None = None,
-        e_cz: u.Quantity | None = None,
-        e_z: float | None = None,
-    ) -> Self:
-        if not interface.is_nan(cz):
-            data_cz = astronomy.to(cz, "m/s")
-        elif not interface.is_nan(z):
-            data_cz = astronomy.to(z * astronomy.const("c"), "m/s")
-        else:
-            raise ValueError("neither z nor cz is specified")
-
-        if not interface.is_nan(e_cz):
-            data_e_cz = astronomy.to(e_cz, "m/s")
-        elif not interface.is_nan(e_z):
-            data_e_cz = astronomy.to(e_z * astronomy.const("c"), "m/s")
-        else:
-            raise ValueError("neither e_z nor e_cz is specified")
-
-        return cls(data_cz, data_e_cz)
-
-    def layer0_data(self) -> dict[str, Any]:
-        return {"cz": self.cz, "e_cz": self.e_cz}
-
-    @classmethod
-    def aggregate(cls, objects: list[Self]) -> Self:
-        e_cz = [obj.e_cz for obj in objects]
-
-        cz = sum(obj.cz for obj in objects) / len(objects)
-        e_cz = sum(e_cz) / len(e_cz)
-
-        return cls(cz, e_cz)
-
     def catalog(self) -> interface.RawCatalog:
         return interface.RawCatalog.REDSHIFT
 
@@ -63,9 +24,6 @@ def layer1_table(cls) -> str:
     def layer1_keys(cls) -> list[str]:
         return ["cz", "e_cz"]
 
-    def layer1_data(self) -> dict[str, Any]:
-        return {"cz": self.cz, "e_cz": self.e_cz}
-
     @classmethod
     def from_layer1(cls, data: dict[str, Any]) -> Self:
         return cls(cz=data["cz"], e_cz=data["e_cz"])

app/data/repositories/layer1.py

@@ -4,7 +4,6 @@
 import structlog
 
 from app.data import model
-from app.lib import containers
 from app.lib.storage import postgres
 
 
@@ -35,47 +34,6 @@ def save_structured_data(self, table: str, columns: list[str], ids: list[str], d
         with self.with_tx():
             self._storage.execute_batch(query, rows)
 
-    def save_data(self, records: list[model.Record]) -> None:
-        all_catalog_objects = []
-        for record in records:
-            for catalog_object in record.data:
-                all_catalog_objects.append((record.id, catalog_object))
-
-        table_objects = containers.group_by(all_catalog_objects, lambda item: item[1].layer1_table())
-
-        with self.with_tx():
-            for table, table_items in table_objects.items():
-                if not table_items:
-                    continue
-
-                columns = ["record_id"]
-                columns.extend(table_items[0][1].layer1_keys())
-
-                params = []
-                values = []
-                for record_id, catalog_object in table_items:
-                    data = catalog_object.layer1_data()
-                    data["record_id"] = record_id
-
-                    params.extend([data[column] for column in columns])
-                    values.append(",".join(["%s"] * len(columns)))
-
-                on_conflict_update_statement = ", ".join([f"{column} = EXCLUDED.{column}" for column in columns])
-
-                query = f"""
-                INSERT INTO {table} ({", ".join(columns)}) 
-                VALUES {", ".join([f"({value})" for value in values])}
-                ON CONFLICT (record_id) DO UPDATE SET {on_conflict_update_statement}
-                """
-
-                self._storage.exec(query, params=params)
-
-                self._logger.debug(
-                    "Saved data to layer 1",
-                    table=table,
-                    object_count=len(table_items),
-                )
-
     def get_new_nature_records(
         self, dt: datetime.datetime, limit: int, offset: int
     ) -> list[model.StructuredData[model.NatureRecord]]: