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

clear_skies_cortex-2.0.1.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: clear-skies-cortex
+Version: 2.0.1
+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
+Project-URL: Issues, https://github.com/clearskies-py/cortex/issues
+Project-URL: Changelog, https://github.com/clearskies-py/cortex/blob/main/CHANGELOG.md
+Author-email: Tom Nijboer <tom.nijboer@cimpress.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+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: dacite>=1.9.2
+Provides-Extra: dev
+Requires-Dist: types-requests>=2.32.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+
+# cortex
+
+
+Cortex module for Clearskies
+
+This template scaffolds a dynamic Clearskies module for any kind of logic, integration, or API. You can use it to build modules for data processing, service integration, automation, or any custom business logic.
+
+Your module can implement any logic you need: fetch data, process input, interact with external services, or perform custom actions. The endpoints and payloads are up to you.
+
+## Installation
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Create a virtual environment and install dependencies
+uv sync
+```
+
+## Development
+
+To set up your development environment with pre-commit hooks:
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Create a virtual environment and install all dependencies (including dev)
+uv sync
+
+# Install dev dependencies (including ruff, black, mypy) in the project environment
+uv pip install .[dev]
+
+# Install pre-commit hooks
+uv run pre-commit install
+
+# Optionally, run pre-commit on all files
+uv run pre-commit run --all-files
+```
+
+## Usage Example
+
+```python
+import clearskies
+import clearskies_cortex
+
+wsgi = clearskies.contexts.WsgiRef(
+    clearskies_cortex.build__module()
+)
+wsgi()
+```

clear_skies_cortex-2.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+clearskies_cortex/__init__.py,sha256=SwFkNfKLJgcq2qE6YJ_78_JfeoRGojlKuR_3DymZZSQ,142
+clearskies_cortex/dataclasses.py,sha256=yZhRm2dnGCVGaZUEuh8n86kqqxFTuKU_jljkh0gAW-4,1432
+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/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/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_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_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.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

clear_skies_cortex-2.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Tom Nijboer
+
+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.

clearskies_cortex/__init__.py

@@ -0,0 +1,8 @@
+from clearskies_cortex import backends, columns, defaults, models
+
+__all__ = [
+    "backends",
+    "columns",
+    "defaults",
+    "models",
+]

clearskies_cortex/backends/__init__.py

@@ -0,0 +1,4 @@
+from clearskies_cortex.backends.cortex_backend import CortexBackend
+from clearskies_cortex.backends.cortex_team_relationship_backend import (
+    CortexTeamRelationshipBackend,
+)

clearskies_cortex/backends/cortex_backend.py

@@ -0,0 +1,45 @@
+import clearskies
+from clearskies import configs
+from clearskies.authentication import Authentication
+from clearskies.decorators import parameters_to_properties
+from clearskies.di import inject
+from clearskies.query import Query
+
+
+class CortexBackend(clearskies.backends.ApiBackend):
+    """Backend for Cortex.io."""
+
+    base_url = configs.String(default="https://api.getcortexapp.com/api/v1/")
+    authentication = inject.ByName("cortex_auth")  # type: ignore[assignment]
+    requests = inject.Requests()
+    _auth_headers: dict[str, str] = {}
+
+    api_to_model_map = configs.AnyDict(default={})
+    pagination_parameter_name = configs.String(default="page")
+
+    can_count = True
+
+    @parameters_to_properties
+    def __init__(
+        self,
+        base_url: str | None = "https://api.getcortexapp.com/api/v1/",
+        authentication: Authentication | None = None,
+        model_casing: str = "snake_case",
+        api_casing: str = "camelCase",
+        api_to_model_map: dict[str, str | list[str]] = {},
+        pagination_parameter_name: str = "page",
+        pagination_parameter_type: str = "int",
+        limit_parameter_name: str = "pageSize",
+    ):
+        self.finalize_and_validate_configuration()
+
+    def count(self, query: Query) -> int:
+        """Return count of records matching query."""
+        self.check_query(query)
+        (url, method, body, headers) = self.build_records_request(query)
+        response = self.execute_request(url, method, json=body, headers=headers)
+        response.raise_for_status()
+        data = response.json()
+        if "total" in data:
+            return data["total"]
+        return len(data)

clearskies_cortex/backends/cortex_team_relationship_backend.py

@@ -0,0 +1,174 @@
+import json
+import logging
+import uuid
+from types import SimpleNamespace
+from typing import Any
+
+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_cortex.backends import cortex_backend as rest_backend
+
+
+class CortexTeamRelationshipBackend(MemoryBackend, Configurable):
+    """Backend for Cortex.io."""
+
+    logger = logging.getLogger(__name__)
+    di = inject.Di()
+
+    cortex_backend = configs.Any(default=None)
+    _cached_teams: dict[str, dict[str, Any]]
+
+    def __init__(
+        self,
+        cortex_backend,
+        silent_on_missing_tables=True,
+    ):
+        super().__init__(silent_on_missing_tables)
+        # This backend has its dependencies injected automatically because it is attachd to the model,
+        # but when you directly instantiate the CortexBackend and pass it in, the di system never has a chance
+        # to provide IT with the necessary deendencies.  Therefore, we just have to explicitly do it,
+        # 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]]:
+        """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:
+            self._tables[table_name] = MemoryTable(query.model_class)
+            [records, id_index] = self._fetch_and_map_relationship_data(table_name)
+            # directly setting internal things is bad, but the create function on the MemoryTable
+            # (which is how we _should_ feed data into it) does a lot of extra data validation that
+            # 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)
+
+    def _fetch_and_map_relationship_data(self, table_name: str) -> tuple[list[dict[str, str | int]], dict[str, int]]:
+        class RelationshipModel(Model):
+            id_column_name: str = "id"
+            backend = rest_backend.CortexBackend()
+
+            id = String()
+            child_team_tag = String()
+            parent_team_tag = String()
+            provider = String()
+
+            @classmethod
+            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
+        # cache the result so it only has to happen once).  The trouble is that we need to know the tree before
+        # we can get started.  We want to start at the top or the bottom, but Cortex gives us neither.
+        # therefore, we'll search for the root categories and then start over.  While we find those, we'll
+        # convert from a list of edges to a dictionary of parent/children
+
+        # Fetch all teams and filter out archived ones
+        from clearskies_cortex.models.cortex_team import CortexTeam
+
+        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"]
+            # Skip if either parent or child is archived
+            if parent_category not in relationships:
+                relationships[parent_category] = set()
+            relationships[parent_category].add(child_category)
+            known_children[child_category] = child_category
+            if parent_category not in known_children:
+                root_categories[parent_category] = parent_category
+            if child_category in root_categories:
+                del root_categories[child_category]
+
+        mapped_records: list[dict[str, str | int]] = []
+        id_index: dict[str, int] = {}
+        # now we can work our way down the tree, starting at the root categories
+
+        nested_tree = self._build_nested_tree(relationships, root_categories)
+
+        def traverse_all_paths(node, ancestors):
+            mapped = []
+            node_name = node["name"]
+            # For every ancestor path, emit a record for each ancestor-child pair
+            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")
+                ):
+                    continue
+                mapped.append(
+                    {
+                        "id": str(uuid.uuid4()),
+                        "parent_team_tag": ancestor,
+                        "child_team_tag": node_name,
+                        "is_parent": 1 if idx == len(ancestors) - 1 and len(ancestors) > 0 else 0,
+                        "level": idx + 1,
+                    }
+                )
+            # Recurse for each child, passing a *copy* of ancestors + this node
+            for child in node.get("children", []):
+                mapped.extend(traverse_all_paths(child, ancestors + [node_name]))
+            return mapped
+
+        for root in nested_tree.values():
+            mapped_records.extend(traverse_all_paths(root, []))
+        # now build our id index
+        id_index = {str(record["id"]): index for (index, record) in enumerate(mapped_records)}
+
+        return (mapped_records, id_index)
+
+    def _build_nested_tree(self, relationships: dict[str, set[str]], root_categories: dict[str, str]) -> dict:
+        def build_subtree(node):
+            return {"name": node, "children": [build_subtree(child) for child in relationships.get(node, [])]}
+
+        return {root: build_subtree(root) for root in root_categories}
+
+    def _get_cortex_backend(self) -> rest_backend.CortexBackend:
+        """Return the cortex backend."""
+        if self.cortex_backend is not None:
+            self.di.inject_properties(self.cortex_backend.__class__)
+        else:
+            self.cortex_backend = self.di.build_class(rest_backend.CortexBackend)
+        return self.cortex_backend
+
+    def all_teams(self) -> dict[str, dict[str, Any]]:
+        """Return all teams from cortex."""
+        if hasattr(self, "_cached_teams"):
+            return self._cached_teams
+
+        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
+        self._cached_teams = teams
+        return teams

clearskies_cortex/columns/__init__.py

@@ -0,0 +1,3 @@
+from clearskies_cortex.columns.string_list import StringList
+
+__all__ = ["StringList"]

clearskies_cortex/columns/string_list.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from clearskies.columns import String
+
+
+class StringList(String):
+    """Column type for comma delimited string."""
+
+    def from_backend(self, value: str | list[str]) -> list[str]:
+        """Return comma delimited string to list."""
+        if isinstance(value, list):
+            return value
+        return value.split(",")
+
+    def to_backend(self, data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Make any changes needed to save the data to the backend.
+
+        This typically means formatting changes - converting DateTime objects to database
+        date strings, etc...
+        """
+        if self.name not in data:
+            return data
+
+        return {**data, self.name: str(",".join(data[self.name]))}

clearskies_cortex/dataclasses.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ServiceEntityHierarchy:
+    """Dataclass for parent in service hierarchy."""
+
+    parents: list["ServiceEntityHierarchyParent"]
+    children: list["ServiceEntityHierarchyChild"]
+
+
+@dataclass
+class ServiceEntityHierarchyParent:
+    """Dataclass for parent in hierarchy."""
+
+    tag: str
+    type: str
+    name: str
+    description: str | None
+    definition: None | dict[str, Any]
+    parents: list["ServiceEntityHierarchyParent"]
+    groups: list[str]
+
+
+@dataclass
+class ServiceEntityHierarchyChild:
+    """Dataclass for child in hierarchy."""
+
+    tag: str
+    type: str
+    name: str
+    description: str | None
+    definition: None | dict[str, Any]
+    children: list["ServiceEntityHierarchyChild"]
+    groups: list[str]
+
+
+@dataclass
+class TeamCategory:
+    """Dataclass for Team Category Tree."""
+
+    name: str
+    level: int
+    parent_name: str
+
+
+@dataclass
+class EntityTeam:
+    """Dataclass for team in Catalog Entity."""
+
+    description: str | None
+    inheritance: str
+    isArchived: bool  # noqa: N815
+    name: str
+    provider: str
+    tag: str
+
+
+@dataclass
+class EntityIndividual:
+    """Dataclass for individual in Catalog Entity."""
+
+    description: str | None
+    email: str
+
+
+@dataclass
+class EntityTeamOwner:
+    """Dataclass for team owners in Catalog Entity."""
+
+    teams: list[EntityTeam]
+    individuals: list[EntityIndividual]

clearskies_cortex/defaults/__init__.py

@@ -0,0 +1,7 @@
+from clearskies_cortex.defaults.default_cortex_auth import DefaultCortexAuth
+from clearskies_cortex.defaults.default_cortex_url import DefaultCortexUrl
+
+__all__ = [
+    "DefaultCortexUrl",
+    "DefaultCortexAuth",
+]

clearskies_cortex/defaults/default_cortex_auth.py

@@ -0,0 +1,9 @@
+import clearskies
+
+
+class DefaultCortexAuth(clearskies.di.AdditionalConfigAutoImport):
+    def provide_cortex_auth(self, environment: clearskies.Environment):
+        if environment.get("CORTEX_AUTH_SECRET_PATH", True):
+            secret_key = environment.get("CORTEX_AUTH_SECRET_PATH")
+            return clearskies.authentication.SecretBearer(secret_key=secret_key, header_prefix="Bearer ")
+        return clearskies.authentication.SecretBearer(environment_key="CORTEX_AUTH_KEY", header_prefix="Bearer ")

clearskies_cortex/defaults/default_cortex_url.py

@@ -0,0 +1,7 @@
+import clearskies
+
+
+class DefaultCortexUrl(clearskies.di.AdditionalConfigAutoImport):
+    def provide_cortex_url(self, environment: clearskies.Environment) -> str:
+        cortex_url = environment.get("CORTEX_URL", True)
+        return cortex_url if cortex_url else "https://api.getcortexapp.com/api/v1/"

clearskies_cortex/models/__init__.py

@@ -0,0 +1,21 @@
+from clearskies_cortex.models.cortex_catalog_entity import CortexCatalogEntity
+from clearskies_cortex.models.cortex_catalog_entity_domain import CortexCatalogEntityDomain
+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_scorecard import CortexScorecard
+from clearskies_cortex.models.cortex_team import CortexTeam
+from clearskies_cortex.models.cortex_team_category_tree import CortexTeamCategoryTree
+from clearskies_cortex.models.cortex_team_department import CortexTeamDepartment
+
+__all__ = [
+    "CortexCatalogEntity",
+    "CortexCatalogEntityDomain",
+    "CortexCatalogEntityGroup",
+    "CortexCatalogEntityScorecard",
+    "CortexCatalogEntityService",
+    "CortexScorecard",
+    "CortexTeam",
+    "CortexTeamCategoryTree",
+    "CortexTeamDepartment",
+]

clearskies_cortex/models/cortex_catalog_entity.py

@@ -0,0 +1,62 @@
+from typing import Self
+
+from clearskies import Model
+from clearskies.columns import Boolean, Datetime, HasMany, Json, String
+
+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
+
+
+class CortexCatalogEntity(Model):
+    """Model for entities."""
+
+    id_column_name: str = "tag"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "catalog"
+
+    id = String()
+    tag = String()
+    groups = StringList("groups")
+    owners = Json()
+    ownership = Json()
+    ownersV2 = Json()
+    description = String()
+    git = Json()
+    hierarchy = Json()
+    last_updated = Datetime()
+    is_archived = Boolean()
+    links = Json()
+    members = Json()
+    metadata = Json()
+    slack_channels = Json()
+    name = String()
+    type = String()
+    scorecards = HasMany(
+        cortex_catalog_entity_scorecard.CortexCatalogEntityScorecard,
+        foreign_column_name="entity_tag",
+    )
+    group_models = HasMany(
+        cortex_catalog_entity_group.CortexCatalogEntityGroup,
+        foreign_column_name="entity_tag",
+    )
+
+    def parse_groups(self) -> dict[str, str]:
+        """
+        Parse the strings of groups.
+
+        The groups is a list of string with key,value splitted by ':'.
+        Return a dict with key value.
+        """
+        parsed: dict[str, str] = {}
+        if self.groups:
+            for entity in self.groups:
+                splitted = entity.split(":")
+                if len(splitted) > 1:
+                    parsed[splitted[0]] = splitted[1]
+        return parsed

clearskies_cortex/models/cortex_catalog_entity_domain.py

@@ -0,0 +1,25 @@
+from typing import Any, Self
+
+from clearskies import Column
+
+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:
+        return (
+            model.where("types=domain")
+            .where("include_nested_fields=team:members")
+            .where("include_owners=true")
+            .where("include_metadata=true")
+            .where("include_hierarchy_fields=groups")
+        )

clearskies_cortex/models/cortex_catalog_entity_group.py

@@ -0,0 +1,22 @@
+from typing import Self
+
+from clearskies import Model
+from clearskies.columns import Json, String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexCatalogEntityGroup(Model):
+    """Model for teams."""
+
+    id_column_name: str = "entity_tag"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "catalog/{entity_tag}/groups"
+
+    entity_tag = String()
+    tag = Json()

clearskies_cortex/models/cortex_catalog_entity_scorecard.py

@@ -0,0 +1,33 @@
+from collections import OrderedDict
+from typing import Any, Self
+
+from clearskies import Model
+from clearskies.columns import Float, Integer, Json, String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexCatalogEntityScorecard(Model):
+    """Model for teams."""
+
+    id_column_name: str = "scorecard_id"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "catalog/:entity_tag/scorecards"
+
+    scorecard_id = Integer()
+    entity_tag = String()
+    ladder_levels = Json()
+    score = Integer()
+    score_percentage = Float()
+    score_card_name = String()
+    total_possible_score = Integer()
+
+    def get_score_card_tag_name(self) -> str:
+        """Transform the scorecardName to scorecard tag."""
+        name: str = self.score_card_name
+        return name

clearskies_cortex/models/cortex_catalog_entity_service.py

@@ -0,0 +1,92 @@
+import logging
+from typing import Any, Self, cast
+
+from clearskies import Column
+from clearskies.di import inject
+from dacite import from_dict
+
+from clearskies_cortex import dataclasses
+from clearskies_cortex.backends import CortexBackend
+from clearskies_cortex.models import (
+    cortex_catalog_entity,
+    cortex_catalog_entity_domain,
+    cortex_team,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CortexCatalogEntityService(cortex_catalog_entity.CortexCatalogEntity):
+    """Model for domain entities."""
+
+    backend = CortexBackend()
+
+    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."""
+        return (
+            model.where("types=service")
+            .where("include_nested_fields=team:members")
+            .where("include_owners=true")
+            .where("include_metadata=true")
+            .where("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()
+
+        return team
+
+    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:
+            return team
+
+        logger.debug(f"EntityService: ownersV2 {self.ownersV2}")
+        owners = from_dict(dataclasses.EntityTeamOwner, data=self.ownersV2)
+
+        if not owners.teams:
+            return team
+
+        entity_team = owners.teams[0]
+        logger.debug(f"Found entity team: {entity_team}")
+
+        return self.teams.find(f"team_tag={entity_team.tag}")

clearskies_cortex/models/cortex_catalog_entity_types.py

@@ -0,0 +1,25 @@
+from typing import Self
+
+from clearskies import Model
+from clearskies.columns import Json, String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexCatalogEntityType(Model):
+    """Model for entities."""
+
+    id_column_name: str = "type"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "catalog/definitions"
+
+    name = String()
+    description = String()
+    schema = Json()
+    source = String()
+    type = String()

clearskies_cortex/models/cortex_entity_relationships.py

@@ -0,0 +1,25 @@
+from typing import Self
+
+from clearskies import Model
+from clearskies.columns import String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexCatalogEntityRelationship(Model):
+    """Model for entities."""
+
+    id_column_name: str = "tag"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "catalog/:tag/relationships/:relationship_type_tag/destinations"
+
+    id = String()
+    tag = String()
+    description = String()
+    name = String()
+    type = String()

clearskies_cortex/models/cortex_model.py

@@ -0,0 +1,9 @@
+from clearskies import Model
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexModel(Model):
+    """Base model for cortex."""
+
+    backend = CortexBackend()

clearskies_cortex/models/cortex_scorecard.py

@@ -0,0 +1,27 @@
+from collections import OrderedDict
+from typing import Any, Self
+
+from clearskies import Model
+from clearskies.columns import Boolean, Json, String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexScorecard(Model):
+    """Model for scorecards."""
+
+    id_column_name: str = "scorecard_tag"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "scorecards"
+
+    scorecard_tag = String()
+    catalog_entity_tag = String()
+    is_archived = Boolean()
+    links = Json()
+    metadata = Json()
+    slack_channels = Json()

clearskies_cortex/models/cortex_team.py

@@ -0,0 +1,69 @@
+from typing import Self, cast
+
+from clearskies import Model
+from clearskies.columns import (
+    BelongsToModel,
+    Boolean,
+    CategoryTree,
+    CategoryTreeAncestors,
+    CategoryTreeChildren,
+    CategoryTreeDescendants,
+    Json,
+    String,
+)
+
+from clearskies_cortex.backends import CortexBackend
+from clearskies_cortex.models import cortex_team_category_tree
+
+
+class CortexTeam(Model):
+    """Model for teams."""
+
+    id_column_name: str = "team_tag"
+
+    backend = CortexBackend()
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "teams"
+
+    team_tag = String()
+    catalog_entity_tag = String()
+    is_archived = Boolean()
+    parent_team_tag = CategoryTree(
+        cortex_team_category_tree.CortexTeamCategoryTree,
+        load_relatives_strategy="individual",
+        tree_child_id_column_name="child_team_tag",
+        tree_parent_id_column_name="parent_team_tag",
+    )
+    parent = BelongsToModel("parent_team_tag")
+    children = CategoryTreeChildren("parent_team_tag")
+    ancestors = CategoryTreeAncestors("parent_team_tag")
+    descendants = CategoryTreeDescendants("parent_team_tag")
+    links = Json()
+    metadata = Json()
+    slack_channels = Json()
+    type = String()
+    cortex_team = Json()
+    id = String()
+
+    def get_name(self) -> str:
+        """Retrieve name from metadata."""
+        return str(self.metadata.get("name", "")) if self.metadata else ""
+
+    def has_parents(self) -> bool:
+        """Check if team has parents. If not it's a top-level team."""
+        return len(self.ancestors) > 0
+
+    def has_childeren(self) -> bool:
+        """Check if team has child. If not it's a bottom-level team."""
+        return len(self.children) > 0
+
+    def find_top_level_team(self: Self) -> Self:
+        """
+        Find the top-level team of the team.
+
+        If team not has parents, return itself.
+        """
+        return self if not self.has_parents() else self.ancestors[0]  # type: ignore[index]

clearskies_cortex/models/cortex_team_category_tree.py

@@ -0,0 +1,27 @@
+import uuid
+from collections import OrderedDict
+from typing import Any, Iterator, Self
+
+from clearskies import Model
+from clearskies.columns import Boolean, Integer, String, Uuid
+
+from clearskies_cortex.backends import CortexBackend, CortexTeamRelationshipBackend
+
+
+class CortexTeamCategoryTree(Model):
+    """Model for teams."""
+
+    id_column_name: str = "id"
+
+    backend = CortexTeamRelationshipBackend(CortexBackend())
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "teams/relationships"
+
+    id = Uuid()
+    parent_team_tag = String()
+    child_team_tag = String()
+    is_parent = Boolean()
+    level = Integer()

clearskies_cortex/models/cortex_team_department.py

@@ -0,0 +1,25 @@
+from collections import OrderedDict
+from typing import Any, Self
+
+from clearskies import Model
+from clearskies.columns import Json, String
+
+from clearskies_cortex.backends import CortexBackend
+
+
+class CortexTeamDepartment(Model):
+    """Model for departments."""
+
+    backend = CortexBackend()
+    id_column_name: str = "department_tag"
+
+    @classmethod
+    def destination_name(cls: type[Self]) -> str:
+        """Return the slug of the api endpoint for this model."""
+        return "teams/departments"
+
+    department_tag = String()
+    catalog_entity_tag = String()
+    description = String()
+    name = String()
+    members = Json()