clear-skies-cortex 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

{clear_skies_cortex-2.0.1.dist-info → clear_skies_cortex-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clear-skies-cortex
-Version: 2.0.1
+Version: 2.0.3
 Summary: Cortex module for Clearskies
 Project-URL: Docs, https://https://clearskies.info/modules/clear-skies-cortex
 Project-URL: Repository, https://github.com/clearskies-py/cortex
@@ -14,7 +14,7 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: <4.0,>=3.11
-Requires-Dist: clear-skies<3.0.0,>=2.0.0
+Requires-Dist: clear-skies<3.0.0,>=2.0.37
 Requires-Dist: dacite>=1.9.2
 Provides-Extra: dev
 Requires-Dist: types-requests>=2.32.4; extra == 'dev'

{clear_skies_cortex-2.0.1.dist-info → clear_skies_cortex-2.0.3.dist-info}/RECORD

@@ -1,27 +1,28 @@
 clearskies_cortex/__init__.py,sha256=SwFkNfKLJgcq2qE6YJ_78_JfeoRGojlKuR_3DymZZSQ,142
-clearskies_cortex/dataclasses.py,sha256=yZhRm2dnGCVGaZUEuh8n86kqqxFTuKU_jljkh0gAW-4,1432
+clearskies_cortex/dataclasses.py,sha256=rmSwJkMPwyfQltHuGzRRn9OrwMXKHajkG1jA39ix9lU,1446
 clearskies_cortex/backends/__init__.py,sha256=Ek74kpJLE7ERY-6yhH2KwFO25gm3Yjz51laUApnhgnU,179
-clearskies_cortex/backends/cortex_backend.py,sha256=OnbrHXjojBWoOBYRjfKD26FO7XzzYsVrpWJAfQ95wn0,1650
-clearskies_cortex/backends/cortex_team_relationship_backend.py,sha256=IHvYzDMcmUqJHjdWzm1QtNbwWD9LbUNMRQVUC2Afx-U,7795
+clearskies_cortex/backends/cortex_backend.py,sha256=kmF54P0W3eK2BpCAh4dpIBPmo6iWKU7oUYSPB-IG7IE,4149
+clearskies_cortex/backends/cortex_team_relationship_backend.py,sha256=UiMZp0jcKvpx3tLbR8aMBS8-KIfECxJGiwM3fz8DmuM,7648
 clearskies_cortex/columns/__init__.py,sha256=BpoVCEVXRtKcsyRFnAYLtlwYtHBjciUbzuzaBxmfH00,87
 clearskies_cortex/columns/string_list.py,sha256=khsJS_0T4XZvTeXFpRvZsFX8iNTWbx_urCEa9Tv0Bmo,754
 clearskies_cortex/defaults/__init__.py,sha256=tulZSvFgp4YUKj_bnArIevmlpC8z_AQKO0okYs4hCDo,216
 clearskies_cortex/defaults/default_cortex_auth.py,sha256=yA5kCwGxPEdV2t-28UArkKXgI3qbxt-7P6az4cLI1Rg,508
 clearskies_cortex/defaults/default_cortex_url.py,sha256=SaR6dQW3ELtuy4Woap8ufYL_zGQ0K0XwHUv0CYi_p78,305
-clearskies_cortex/models/__init__.py,sha256=aJXrP5UwHCoKe833Mpg4hbTEftXSgAdRFXrUYZ0KGOA,1026
-clearskies_cortex/models/cortex_catalog_entity.py,sha256=-7lo67x09N-iNWRGKpdDrn1raGyhH1oL8UpscUVxb9I,1766
-clearskies_cortex/models/cortex_catalog_entity_domain.py,sha256=UTa2vBGt8DuTFrO_Prcckb0NXHB0YsppZv47D3NmpFs,735
+clearskies_cortex/models/__init__.py,sha256=zckJ4-KOjIcmtN7h7lXOESUu3d6JBsZZJq-s2MJ0NLQ,1145
+clearskies_cortex/models/cortex_catalog_entity.py,sha256=ASwCKiZ682YvsFUrkPo8J_MQYCT_39aElJGWDTDH7GQ,3060
+clearskies_cortex/models/cortex_catalog_entity_domain.py,sha256=gApQwSIGO0UGxhkJo-aaDK7clCxmTQTzHcgCjdPAZEE,1386
 clearskies_cortex/models/cortex_catalog_entity_group.py,sha256=dvuwwuj8Mwm0HgqVjkz1MpUycBAl9WUrDNC0XNGeWGk,514
 clearskies_cortex/models/cortex_catalog_entity_scorecard.py,sha256=sWp_v7O9uY3VbJjdb_VWUPHgBIn-rRj6kZDHqZq4lXI,908
-clearskies_cortex/models/cortex_catalog_entity_service.py,sha256=4Ibodm7orM9O_HZB1BkAVgYkM2st8Cm9iBO-qdyffhM,3344
+clearskies_cortex/models/cortex_catalog_entity_service.py,sha256=GeJmR9qfRjNFwxbJriJeTWMm4L4yH-z6wCXQWXAolg4,2780
+clearskies_cortex/models/cortex_catalog_entity_team.py,sha256=mKVKjOMf0xOk53XJI8juPQzNSdHvmxI1bJWfQVCKEQQ,1364
 clearskies_cortex/models/cortex_catalog_entity_types.py,sha256=EJBRv0ZMHwZ6HpaXxy0A_EBGqmu9EeVAZiX4xPIljz4,568
 clearskies_cortex/models/cortex_entity_relationships.py,sha256=bB46YFK8Vc2SZsvobvFeyTfEj8YfcaXFaPnkW0o_nG4,607
 clearskies_cortex/models/cortex_model.py,sha256=QmwQ45vuK4iUKCJsOk1pwu1at8IYKg39pYO9TtlYrEA,175
 clearskies_cortex/models/cortex_scorecard.py,sha256=YlINfUGudmqQHe-0ZpD2qOzAUKWshUycwgXYEcxqsUk,663
-clearskies_cortex/models/cortex_team.py,sha256=wPJxkNV1qQPq4WwMhBdKBnotQAB9KbmdVpowWCmfqp0,2042
+clearskies_cortex/models/cortex_team.py,sha256=LXqHx_lwBvuVMyUlj1l2Sfpngj0zTZGpVi0WrJP-o3E,2246
 clearskies_cortex/models/cortex_team_category_tree.py,sha256=PLC-9E5kuMeItow7RKFX7jKUiAfJ-7ehXIy3eeaFzr8,721
 clearskies_cortex/models/cortex_team_department.py,sha256=DL3k91462-R0VVqbUQgBfYM_TndE5MKmDPBSF448XYw,639
-clear_skies_cortex-2.0.1.dist-info/METADATA,sha256=LM3SjjrLaNTpz66dKoRs1p6hbOoalJpVN46uWAMg3gc,2116
-clear_skies_cortex-2.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-clear_skies_cortex-2.0.1.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
-clear_skies_cortex-2.0.1.dist-info/RECORD,,
+clear_skies_cortex-2.0.3.dist-info/METADATA,sha256=aDSWFEtcMWOw5fGdQGg1B--y7ECfX89nyI1WRa-36jg,2117
+clear_skies_cortex-2.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+clear_skies_cortex-2.0.3.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
+clear_skies_cortex-2.0.3.dist-info/RECORD,,

clearskies_cortex/backends/cortex_backend.py

@@ -1,9 +1,13 @@
+from typing import Any
+
 import clearskies
-from clearskies import configs
+import requests
+from clearskies import Column, configs
 from clearskies.authentication import Authentication
 from clearskies.decorators import parameters_to_properties
 from clearskies.di import inject
 from clearskies.query import Query
+from clearskies.query.result import CountQueryResult
 
 
 class CortexBackend(clearskies.backends.ApiBackend):
@@ -12,10 +16,13 @@ class CortexBackend(clearskies.backends.ApiBackend):
     base_url = configs.String(default="https://api.getcortexapp.com/api/v1/")
     authentication = inject.ByName("cortex_auth")  # type: ignore[assignment]
     requests = inject.Requests()
+    api_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="camelCase")
+
     _auth_headers: dict[str, str] = {}
 
     api_to_model_map = configs.AnyDict(default={})
     pagination_parameter_name = configs.String(default="page")
+    limit_parameter_name = configs.String(default="pageSize")
 
     can_count = True
 
@@ -33,7 +40,7 @@ class CortexBackend(clearskies.backends.ApiBackend):
     ):
         self.finalize_and_validate_configuration()
 
-    def count(self, query: Query) -> int:
+    def count(self, query: Query) -> CountQueryResult:
         """Return count of records matching query."""
         self.check_query(query)
         (url, method, body, headers) = self.build_records_request(query)
@@ -41,5 +48,54 @@ class CortexBackend(clearskies.backends.ApiBackend):
         response.raise_for_status()
         data = response.json()
         if "total" in data:
-            return data["total"]
-        return len(data)
+            return CountQueryResult(count=data["total"])
+        data = self.map_records_response(data, query)
+        return CountQueryResult(count=len(data))
+
+    def map_records_response(
+        self, response_data: Any, query: Query, query_data: dict[str, Any] | None = None
+    ) -> list[dict[str, Any]]:
+        """Map api response to model fields."""
+        if isinstance(response_data, dict):
+            if "page" in response_data:
+                del response_data["page"]
+                del response_data["totalPages"]
+                del response_data["total"]
+            first_item = next(iter(response_data))
+            if isinstance(response_data[first_item], list) and all(
+                isinstance(item, dict) for item in response_data[first_item]
+            ):
+                return super().map_records_response(response_data[first_item], query, query_data)
+        return super().map_records_response(response_data, query, query_data)
+
+    def set_next_page_data_from_response(
+        self,
+        next_page_data: dict[str, Any],
+        query: Query,
+        response: "requests.Response",  # type: ignore
+    ) -> None:
+        """
+        Update the next_page_data dictionary with the appropriate data needed to fetch the next page of records.
+
+        This method has a very important job, which is to inform clearskies about how to make another API call to fetch the next
+        page of records.  The way this happens is by updating the `next_page_data` dictionary in place with whatever pagination
+        information is necessary.  Note that this relies on next_page_data being passed by reference, hence the need to update
+        it in place.  That means that you can do this:
+
+        ```python
+        next_page_data["some_key"] = "some_value"
+        ```
+
+        but if you do this:
+
+        ```python
+        next_page_data = {"some_key": "some_value"}
+        ```
+
+        Then things simply won't work.
+        """
+        if isinstance(response.json(), dict):
+            page = response.json().get("page", None)
+            total_pages = response.json().get("totalPages", None)
+            if page is not None and total_pages is not None and page < total_pages:
+                next_page_data[self.pagination_parameter_name] = page + 1

clearskies_cortex/backends/cortex_team_relationship_backend.py

@@ -8,7 +8,8 @@ from clearskies import Configurable, Model, configs
 from clearskies.backends.memory_backend import MemoryBackend, MemoryTable
 from clearskies.columns import String, Uuid
 from clearskies.di import inject
-from clearskies.query.query import Query
+from clearskies.query import Condition, Query
+from clearskies.query.result import RecordsQueryResult
 
 from clearskies_cortex.backends import cortex_backend as rest_backend
 
@@ -34,7 +35,7 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
         # or we need to let the di system build the CortexBackend.  This change does both:
         self.cortex_backend = cortex_backend
 
-    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
+    def records(self, query: Query) -> RecordsQueryResult:
         """Accept either a model or a model class and creates a "table" for it."""
         table_name = query.model_class.destination_name()
         if table_name not in self._tables:
@@ -45,7 +46,7 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
             # we don't need since we built the data ourselves.  In short, it will be a lot slower, so I cheat.
             self._tables[table_name]._rows = records  # type: ignore[assignment]
             self._tables[table_name]._id_index = id_index  # type: ignore[assignment]
-        return super().records(query, next_page_data)
+        return super().records(query)
 
     def _fetch_and_map_relationship_data(self, table_name: str) -> tuple[list[dict[str, str | int]], dict[str, int]]:
         class RelationshipModel(Model):
@@ -61,20 +62,6 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
             def destination_name(cls) -> str:
                 return "teams/relationships"
 
-        try:
-            relationship_data = self._get_cortex_backend().records(
-                Query(
-                    model_class=RelationshipModel,
-                ),
-                {},
-            )[0]
-
-        except IndexError:
-            relationship_data = {"edges": []}
-
-        # this should match up to exactly what backend.records() will return
-        # relationship_data = example_data["edges"]
-
         # we need to map this to the kind of row structure expected by the category_tree column
         # (see https://github.com/clearskies-py/clearskies/blob/main/src/clearskies/columns/category_tree.py)
         # This takes slightly more time up front but makes for quick lookups in both directions (and we'll
@@ -89,9 +76,17 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
         root_categories: dict[str, str] = {}
         known_children: dict[str, str] = {}
         relationships: dict[str, set[str]] = {}
-        for relationship in relationship_data["edges"]:
-            child_category = relationship["childTeamTag"]
-            parent_category = relationship["parentTeamTag"]
+        for relationship in (
+            self._get_cortex_backend()
+            .records(
+                Query(
+                    model_class=RelationshipModel,
+                ),
+            )
+            .records
+        ):
+            child_category = relationship["child_team_tag"]
+            parent_category = relationship["parent_team_tag"]
             # Skip if either parent or child is archived
             if parent_category not in relationships:
                 relationships[parent_category] = set()
@@ -115,8 +110,8 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
             for idx, ancestor in enumerate(ancestors):
                 if (
                     not self.all_teams().get(node_name)
-                    or self.all_teams().get(node_name, {}).get("isArchived")
-                    or self.all_teams().get(ancestor, {}).get("isArchived")
+                    # or self.all_teams().get(node_name, {}).get("is_archived")
+                    # or self.all_teams().get(ancestor, {}).get("is_archived")
                 ):
                     continue
                 mapped.append(
@@ -162,13 +157,16 @@ class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
         from clearskies_cortex.models.cortex_team import CortexTeam
 
         teams: dict[str, dict[str, Any]] = {}
-        team_result = self._get_cortex_backend().records(
-            Query(
-                model_class=CortexTeam,
-            ),
-            {},
-        )[0]
-        for team in team_result["teams"]:
-            teams[team["teamTag"]] = team
+        for team in (
+            self._get_cortex_backend()
+            .records(
+                Query(
+                    model_class=CortexTeam,
+                    conditions=[Condition("include_teams_without_members=true")],
+                ),
+            )
+            .records
+        ):
+            teams[team["team_tag"]] = team
         self._cached_teams = teams
         return teams

clearskies_cortex/dataclasses.py

@@ -20,7 +20,7 @@ class ServiceEntityHierarchyParent:
     description: str | None
     definition: None | dict[str, Any]
     parents: list["ServiceEntityHierarchyParent"]
-    groups: list[str]
+    groups: list[str] | None
 
 
 @dataclass
@@ -33,7 +33,7 @@ class ServiceEntityHierarchyChild:
     description: str | None
     definition: None | dict[str, Any]
     children: list["ServiceEntityHierarchyChild"]
-    groups: list[str]
+    groups: list[str] | None
 
 
 @dataclass

clearskies_cortex/models/__init__.py

@@ -3,6 +3,7 @@ from clearskies_cortex.models.cortex_catalog_entity_domain import CortexCatalogE
 from clearskies_cortex.models.cortex_catalog_entity_group import CortexCatalogEntityGroup
 from clearskies_cortex.models.cortex_catalog_entity_scorecard import CortexCatalogEntityScorecard
 from clearskies_cortex.models.cortex_catalog_entity_service import CortexCatalogEntityService
+from clearskies_cortex.models.cortex_catalog_entity_team import CortexCatalogEntityTeam
 from clearskies_cortex.models.cortex_scorecard import CortexScorecard
 from clearskies_cortex.models.cortex_team import CortexTeam
 from clearskies_cortex.models.cortex_team_category_tree import CortexTeamCategoryTree
@@ -14,6 +15,7 @@ __all__ = [
     "CortexCatalogEntityGroup",
     "CortexCatalogEntityScorecard",
     "CortexCatalogEntityService",
+    "CortexCatalogEntityTeam",
     "CortexScorecard",
     "CortexTeam",
     "CortexTeamCategoryTree",

clearskies_cortex/models/cortex_catalog_entity.py

@@ -1,11 +1,19 @@
-from typing import Self
+from collections.abc import Iterator
+from typing import Any, Self
 
 from clearskies import Model
 from clearskies.columns import Boolean, Datetime, HasMany, Json, String
+from clearskies.di import inject
+from clearskies.query import Query
+from dacite import from_dict
 
+from clearskies_cortex import dataclasses
 from clearskies_cortex.backends import CortexBackend
 from clearskies_cortex.columns import StringList
-from clearskies_cortex.models import cortex_catalog_entity_group, cortex_catalog_entity_scorecard
+from clearskies_cortex.models import (
+    cortex_catalog_entity_group,
+    cortex_catalog_entity_scorecard,
+)
 
 
 class CortexCatalogEntity(Model):
@@ -25,7 +33,7 @@ class CortexCatalogEntity(Model):
     groups = StringList("groups")
     owners = Json()
     ownership = Json()
-    ownersV2 = Json()
+    owners_v2 = Json()
     description = String()
     git = Json()
     hierarchy = Json()
@@ -46,6 +54,22 @@ class CortexCatalogEntity(Model):
         foreign_column_name="entity_tag",
     )
 
+    # search columns
+    hierarchy_depth = String(is_searchable=True, is_temporary=True)
+    git_repositories = StringList(is_searchable=True, is_temporary=True)
+    types = StringList(is_searchable=True, is_temporary=True)
+    query = String(is_searchable=True, is_temporary=True)
+    include_archived = Boolean(is_searchable=True, is_temporary=True)
+    include_metadata = Boolean(is_searchable=True, is_temporary=True)
+    include_links = Boolean(is_searchable=True, is_temporary=True)
+    include_owners = Boolean(is_searchable=True)
+    include_nested_fields = StringList(is_searchable=True, is_temporary=True)
+    include_hierarchy_fields = StringList(is_searchable=True, is_temporary=True)
+
+    def parse_hierarchy(self) -> dataclasses.ServiceEntityHierarchy:
+        """Parse the hierarchy column into a dictionary."""
+        return from_dict(dataclasses.ServiceEntityHierarchy, data=self.hierarchy)
+
     def parse_groups(self) -> dict[str, str]:
         """
         Parse the strings of groups.
@@ -60,3 +84,7 @@ class CortexCatalogEntity(Model):
                 if len(splitted) > 1:
                     parsed[splitted[0]] = splitted[1]
         return parsed
+
+    def parse_owners(self) -> dataclasses.EntityTeamOwner:
+        """Parse the owners column into a dictionary."""
+        return from_dict(dataclasses.EntityTeamOwner, data=self.owners)

clearskies_cortex/models/cortex_catalog_entity_domain.py

@@ -1,6 +1,7 @@
 from typing import Any, Self
 
 from clearskies import Column
+from clearskies.query import Condition, Query
 
 from clearskies_cortex.models import cortex_catalog_entity
 
@@ -8,18 +9,30 @@ from clearskies_cortex.models import cortex_catalog_entity
 class CortexCatalogEntityDomain(cortex_catalog_entity.CortexCatalogEntity):
     """Model for domain entities."""
 
-    def where_for_request(
-        self: Self,
-        model: Self,
-        input_output: Any,
-        routing_data: dict[str, str],
-        authorization_data: dict[str, Any],
-        overrides: dict[str, Column] = {},
-    ) -> Self:
+    def get_final_query(self) -> Query:
         return (
-            model.where("types=domain")
-            .where("include_nested_fields=team:members")
-            .where("include_owners=true")
-            .where("include_metadata=true")
-            .where("include_hierarchy_fields=groups")
+            self.get_query()
+            .add_where(Condition("types=domain"))
+            .add_where(Condition("include_nested_fields=team:members"))
+            .add_where(Condition("include_owners=true"))
+            .add_where(Condition("include_metadata=true"))
+            .add_where(Condition("include_hierarchy_fields=groups"))
         )
+
+    def get_top_level_domain(self: Self) -> Self:
+        """Get the upper domain of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            parent = hierarchy.parents[0]
+            while parent.parents:
+                parent = parent.parents[0]
+            return self.as_query().find(f"tag={parent.tag}")
+        return self.empty()
+
+    def get_parent(self: Self) -> Self:
+        """Get the first domain of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            container = hierarchy.parents[0]
+            return self.as_query().find(f"tag={container.tag}")
+        return self.empty()

clearskies_cortex/models/cortex_catalog_entity_service.py

@@ -1,8 +1,9 @@
 import logging
-from typing import Any, Self, cast
+from typing import Any, Iterator, Self, cast
 
 from clearskies import Column
 from clearskies.di import inject
+from clearskies.query import Condition, Query
 from dacite import from_dict
 
 from clearskies_cortex import dataclasses
@@ -13,8 +14,6 @@ from clearskies_cortex.models import (
     cortex_team,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class CortexCatalogEntityService(cortex_catalog_entity.CortexCatalogEntity):
     """Model for domain entities."""
@@ -24,51 +23,19 @@ class CortexCatalogEntityService(cortex_catalog_entity.CortexCatalogEntity):
     teams = inject.ByClass(cortex_team.CortexTeam)
     entity_domains = inject.ByClass(cortex_catalog_entity_domain.CortexCatalogEntityDomain)
 
-    def where_for_request(
-        self: Self,
-        model: Self,
-        input_output: Any,
-        routing_data: dict[str, str],
-        authorization_data: dict[str, Any],
-        overrides: dict[str, Column] = {},
-    ) -> Self:
-        """Return iterable models."""
+    def get_final_query(self) -> Query:
         return (
-            model.where("types=service")
-            .where("include_nested_fields=team:members")
-            .where("include_owners=true")
-            .where("include_metadata=true")
-            .where("include_hierarchy_fields=groups")
+            self.get_query()
+            .add_where(Condition("types=service"))
+            .add_where(Condition("include_nested_fields=team:members"))
+            .add_where(Condition("include_owners=true"))
+            .add_where(Condition("include_metadata=true"))
+            .add_where(Condition("include_hierarchy_fields=groups"))
         )
 
-    def get_software_domain(self: Self) -> cortex_catalog_entity_domain.CortexCatalogEntityDomain:
-        """Get the upper domain of this service if set."""
-        hierarchy = from_dict(dataclasses.ServiceEntityHierarchy, data=self.hierarchy)
-        if hierarchy.parents:
-            parent = hierarchy.parents[0]
-            while parent.parents:
-                parent = parent.parents[0]
-            return cast(
-                cortex_catalog_entity_domain.CortexCatalogEntityDomain,
-                self.entity_domains.find(f"tag={parent.tag}"),
-            )
-        return cast(cortex_catalog_entity_domain.CortexCatalogEntityDomain, self.entity_domains.empty())
-
-    def get_software_container(self: Self) -> cortex_catalog_entity_domain.CortexCatalogEntityDomain:
-        """Get the first domain of this service if set."""
-        hierarchy = from_dict(dataclasses.ServiceEntityHierarchy, data=self.hierarchy)
-        if hierarchy.parents:
-            container = hierarchy.parents[0]
-            return cast(
-                cortex_catalog_entity_domain.CortexCatalogEntityDomain,
-                self.entity_domains.find(f"tag={container.tag}"),
-            )
-        return cast(cortex_catalog_entity_domain.CortexCatalogEntityDomain, self.entity_domains.empty())
-
     def get_top_level_team(self: Self) -> cortex_team.CortexTeam:
         """Find the top level team based on the team ownership."""
         team = self.get_team()
-
         if team:
             return team.find_top_level_team()
 
@@ -76,17 +43,34 @@ class CortexCatalogEntityService(cortex_catalog_entity.CortexCatalogEntity):
 
     def get_team(self: Self) -> cortex_team.CortexTeam:
         """Find the team based on the team ownership."""
-        team = cast(cortex_team.CortexTeam, self.teams.empty())
-        if not self.ownersV2:
+        team = self.teams.empty()
+        self.logger.debug(f"EntityService: owners {self.owners}")
+        if not self.owners:
             return team
-
-        logger.debug(f"EntityService: ownersV2 {self.ownersV2}")
-        owners = from_dict(dataclasses.EntityTeamOwner, data=self.ownersV2)
-
+        owners = self.parse_owners()
+        self.logger.debug(f"Parsed owners: {owners}")
         if not owners.teams:
             return team
 
         entity_team = owners.teams[0]
-        logger.debug(f"Found entity team: {entity_team}")
+        self.logger.debug(f"Found entity team: {entity_team}")
 
         return self.teams.find(f"team_tag={entity_team.tag}")
+
+    def get_top_level_domain(self: Self) -> cortex_catalog_entity_domain.CortexCatalogEntityDomain:
+        """Get the upper domain of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            parent = hierarchy.parents[0]
+            while parent.parents:
+                parent = parent.parents[0]
+            return self.entity_domains.find(f"tag={parent.tag}")
+        return self.entity_domains.empty()
+
+    def get_parent_domain(self: Self) -> cortex_catalog_entity_domain.CortexCatalogEntityDomain:
+        """Get the first domain of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            container = hierarchy.parents[0]
+            return self.entity_domains.find(f"tag={container.tag}")
+        return self.entity_domains.empty()

clearskies_cortex/models/cortex_catalog_entity_team.py

@@ -0,0 +1,38 @@
+from typing import Any, Self
+
+from clearskies import Column
+from clearskies.query import Condition, Query
+
+from clearskies_cortex.models import cortex_catalog_entity
+
+
+class CortexCatalogEntityTeam(cortex_catalog_entity.CortexCatalogEntity):
+    """Model for team entities."""
+
+    def get_final_query(self) -> Query:
+        return (
+            self.get_query()
+            .add_where(Condition("types=team"))
+            .add_where(Condition("include_nested_fields=team:members"))
+            .add_where(Condition("include_owners=true"))
+            .add_where(Condition("include_metadata=true"))
+            .add_where(Condition("include_hierarchy_fields=groups"))
+        )
+
+    def get_top_level_team(self: Self) -> Self:
+        """Get the upper team of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            parent = hierarchy.parents[0]
+            while parent.parents:
+                parent = parent.parents[0]
+            return self.as_query().find(f"tag={parent.tag}")
+        return self.empty()
+
+    def get_parent(self: Self) -> Self:
+        """Get the first team of this service if set."""
+        hierarchy = self.parse_hierarchy()
+        if hierarchy.parents:
+            team = hierarchy.parents[0]
+            return self.as_query().find(f"tag={team.tag}")
+        return self.empty()

clearskies_cortex/models/cortex_team.py

@@ -1,4 +1,4 @@
-from typing import Self, cast
+from typing import Self
 
 from clearskies import Model
 from clearskies.columns import (
@@ -8,6 +8,7 @@ from clearskies.columns import (
     CategoryTreeAncestors,
     CategoryTreeChildren,
     CategoryTreeDescendants,
+    Datetime,
     Json,
     String,
 )
@@ -21,7 +22,11 @@ class CortexTeam(Model):
 
     id_column_name: str = "team_tag"
 
-    backend = CortexBackend()
+    backend = CortexBackend(
+        api_to_model_map={
+            "cortexTeam.members": "members",
+        }
+    )
 
     @classmethod
     def destination_name(cls: type[Self]) -> str:
@@ -45,8 +50,10 @@ class CortexTeam(Model):
     metadata = Json()
     slack_channels = Json()
     type = String()
-    cortex_team = Json()
+    members = Json()
     id = String()
+    last_updated = Datetime()
+    include_teams_without_members = Boolean(is_searchable=True, is_temporary=True)
 
     def get_name(self) -> str:
         """Retrieve name from metadata."""