openmetadata-ingestion 1.6.1.0__py3-none-any.whl → 1.6.2.1__py3-none-any.whl

metadata/clients/aws_client.py

@@ -11,12 +11,16 @@
 """
 Module containing AWS Client
 """
+import datetime
 from enum import Enum
-from typing import Any, Optional
+from functools import partial
+from typing import Any, Callable, Dict, Optional, Type, TypeVar
 
 import boto3
 from boto3 import Session
-from pydantic import BaseModel
+from botocore.credentials import RefreshableCredentials
+from botocore.session import get_session
+from pydantic import BaseModel, Field
 
 from metadata.generated.schema.security.credentials.awsCredentials import AWSCredentials
 from metadata.ingestion.models.custom_pydantic import CustomSecretStr
@@ -44,10 +48,27 @@ class AWSAssumeRoleException(Exception):
     """
 
 
+class AWSAssumeRoleCredentialResponse(BaseModel):
+    AccessKeyId: str = Field()
+    SecretAccessKey: str = Field()
+    SessionToken: Optional[str] = Field(
+        default=None,
+    )
+    Expiration: Optional[datetime.datetime] = None
+
+
 class AWSAssumeRoleCredentialWrapper(BaseModel):
-    accessKeyId: str
-    secretAccessKey: CustomSecretStr
-    sessionToken: Optional[str] = None
+    accessKeyId: str = Field()
+    secretAccessKey: CustomSecretStr = Field()
+    sessionToken: Optional[str] = Field(
+        default=None,
+    )
+    expiryTime: Optional[str] = Field()
+
+
+AWSAssumeRoleCredentialFormat = TypeVar(
+    "AWSAssumeRoleCredentialFormat", AWSAssumeRoleCredentialWrapper, Dict
+)
 
 
 class AWSClient:
@@ -65,7 +86,10 @@ class AWSClient:
     @staticmethod
     def get_assume_role_config(
         config: AWSCredentials,
-    ) -> Optional[AWSAssumeRoleCredentialWrapper]:
+        return_type: Type[
+            AWSAssumeRoleCredentialFormat
+        ] = AWSAssumeRoleCredentialWrapper,
+    ) -> Optional[AWSAssumeRoleCredentialFormat]:
         """
         Get temporary credentials from assumed role
         """
@@ -90,12 +114,19 @@ class AWSClient:
             )
 
         if resp:
-            credentials = resp.get("Credentials", {})
-            return AWSAssumeRoleCredentialWrapper(
-                accessKeyId=credentials.get("AccessKeyId"),
-                secretAccessKey=credentials.get("SecretAccessKey"),
-                sessionToken=credentials.get("SessionToken"),
+            credentials: AWSAssumeRoleCredentialResponse = (
+                AWSAssumeRoleCredentialResponse(**resp.get("Credentials", {}))
+            )
+            creds_wrapper = AWSAssumeRoleCredentialWrapper(
+                accessKeyId=credentials.AccessKeyId,
+                secretAccessKey=credentials.SecretAccessKey,
+                sessionToken=credentials.SessionToken,
+                expiryTime=credentials.Expiration.isoformat(),
             )
+            if return_type == Dict:
+                return creds_wrapper.model_dump(by_alias=True)
+            return creds_wrapper
+
         return None
 
     @staticmethod
@@ -105,17 +136,32 @@ class AWSClient:
         aws_session_token: Optional[str],
         aws_region: str,
         profile=None,
+        refresh_using: Optional[Callable] = None,
     ) -> Session:
         """
         The only required param for boto3 is the region.
         The rest of credentials will have fallback strategies based on
         https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials
         """
+        if refresh_using:
+            refreshable_creds = RefreshableCredentials.create_from_metadata(
+                metadata=refresh_using(),
+                refresh_using=refresh_using,
+                method="sts-assume-role",
+            )
+            session = get_session()
+            session._credentials = refreshable_creds  # pylint: disable=protected-access
+            return Session(
+                botocore_session=session, region_name=aws_region, profile_name=profile
+            )
+
         return Session(
             aws_access_key_id=aws_access_key_id,
-            aws_secret_access_key=aws_secret_access_key.get_secret_value()
-            if aws_secret_access_key
-            else None,
+            aws_secret_access_key=(
+                aws_secret_access_key.get_secret_value()
+                if aws_secret_access_key
+                else None
+            ),
             aws_session_token=aws_session_token,
             region_name=aws_region,
             profile_name=profile,
@@ -123,15 +169,16 @@ class AWSClient:
 
     def create_session(self) -> Session:
         if self.config.assumeRoleArn:
-            assume_creds = AWSClient.get_assume_role_config(self.config)
-            if assume_creds:
-                return AWSClient._get_session(
-                    assume_creds.accessKeyId,
-                    assume_creds.secretAccessKey,
-                    assume_creds.sessionToken,
-                    self.config.awsRegion,
-                    self.config.profileName,
-                )
+            return AWSClient._get_session(
+                None,
+                None,
+                None,
+                self.config.awsRegion,
+                self.config.profileName,
+                refresh_using=partial(
+                    AWSClient.get_assume_role_config, self.config, Dict
+                ),
+            )
 
         return AWSClient._get_session(
             self.config.awsAccessKeyId,

metadata/data_quality/api/models.py

@@ -23,6 +23,7 @@ from pydantic import Field
 from metadata.config.common import ConfigModel
 from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteRequest
 from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
 from metadata.ingestion.models.custom_pydantic import BaseModel
@@ -63,6 +64,9 @@ class TableAndTests(BaseModel):
     executable_test_suite: Optional[CreateTestSuiteRequest] = Field(
         None, description="If no executable test suite is found, we'll create one"
     )
+    service_connection: DatabaseConnection = Field(
+        ..., description="Service connection for the given table"
+    )
 
 
 class TestCaseResults(BaseModel):

metadata/data_quality/processor/test_case_runner.py

@@ -27,6 +27,7 @@ from metadata.data_quality.runner.base_test_suite_source import BaseTestSuiteRun
 from metadata.data_quality.runner.core import DataTestsRunner
 from metadata.generated.schema.api.tests.createTestCase import CreateTestCaseRequest
 from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
 )
@@ -93,7 +94,9 @@ class TestCaseRunner(Processor):
             record.table, openmetadata_test_cases
         )
 
-        test_suite_runner = self.get_test_suite_runner(record.table)
+        test_suite_runner = self.get_test_suite_runner(
+            record.table, record.service_connection
+        )
 
         logger.debug(
             f"Found {len(openmetadata_test_cases)} test cases for table {record.table.fullyQualifiedName.root}"
@@ -351,9 +354,9 @@ class TestCaseRunner(Processor):
                 result.append(tc)
         return result
 
-    def get_test_suite_runner(self, table: Table):
+    def get_test_suite_runner(
+        self, table: Table, service_connection: DatabaseConnection
+    ):
         return BaseTestSuiteRunner(
-            self.config,
-            self.metadata,
-            table,
+            self.config, self.metadata, table, service_connection
         ).get_data_quality_runner()

metadata/data_quality/runner/base_test_suite_source.py

@@ -46,11 +46,12 @@ class BaseTestSuiteRunner:
         config: OpenMetadataWorkflowConfig,
         ometa_client: OpenMetadata,
         entity: Table,
+        service_connection: DatabaseConnection,
     ):
         self.validator_builder_class = ValidatorBuilder
         self._interface = None
         self.entity = entity
-        self.service_conn_config = self._copy_service_config(config, self.entity.database)  # type: ignore
+        self.service_conn_config = self._copy_service_config(service_connection, self.entity.database)  # type: ignore
         self._interface_type: str = self.service_conn_config.type.value.lower()
 
         self.source_config = TestSuitePipeline.model_validate(
@@ -67,7 +68,7 @@ class BaseTestSuiteRunner:
         self._interface = interface
 
     def _copy_service_config(
-        self, config: OpenMetadataWorkflowConfig, database: EntityReference
+        self, service_connection: DatabaseConnection, database: EntityReference
     ) -> DatabaseConnection:
         """Make a copy of the service config and update the database name
 
@@ -77,9 +78,7 @@ class BaseTestSuiteRunner:
         Returns:
             DatabaseService.__config__
         """
-        config_copy = deepcopy(
-            config.source.serviceConnection.root.config  # type: ignore
-        )
+        config_copy = deepcopy(service_connection.config)  # type: ignore
         if hasattr(
             config_copy,  # type: ignore
             "supportsDatabase",

metadata/data_quality/source/test_suite.py

@@ -14,11 +14,17 @@ Test Suite Workflow Source
 
 The main goal is to get the configured table from the API.
 """
-from typing import Iterable, List, Optional, cast
+import itertools
+import traceback
+from typing import Dict, Iterable, List, Optional, cast
 
 from metadata.data_quality.api.models import TableAndTests
 from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteRequest
 from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.databaseService import (
+    DatabaseConnection,
+    DatabaseService,
+)
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
 )
@@ -36,7 +42,7 @@ from metadata.ingestion.api.parser import parse_workflow_config_gracefully
 from metadata.ingestion.api.step import Step
 from metadata.ingestion.api.steps import Source
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.utils import fqn
+from metadata.utils import entity_link, fqn
 from metadata.utils.constants import CUSTOM_CONNECTOR_PREFIX
 from metadata.utils.logger import test_suite_logger
 from metadata.utils.service_spec.service_spec import import_source_class
@@ -61,18 +67,36 @@ class TestSuiteSource(Source):
 
         self.source_config: TestSuitePipeline = self.config.source.sourceConfig.config
 
+        # Build at runtime - if not informed in the yaml - the service connection map
+        self.service_connection_map: Dict[
+            str, DatabaseConnection
+        ] = self._load_yaml_service_connections()
+
         self.test_connection()
 
     @property
     def name(self) -> str:
         return "OpenMetadata"
 
+    def _load_yaml_service_connections(self) -> Dict[str, DatabaseConnection]:
+        """Load the service connections from the YAML file"""
+        service_connections = self.source_config.serviceConnections
+        if not service_connections:
+            return {}
+        return {
+            conn.serviceName: cast(DatabaseConnection, conn.serviceConnection.root)
+            for conn in service_connections
+        }
+
     def _get_table_entity(self) -> Optional[Table]:
         """given an entity fqn return the table entity
 
         Args:
             entity_fqn: entity fqn for the test case
         """
+        # Logical test suites don't have associated tables
+        if self.source_config.entityFullyQualifiedName is None:
+            return None
         table: Table = self.metadata.get_by_name(
             entity=Table,
             fqn=self.source_config.entityFullyQualifiedName.root,
@@ -81,23 +105,51 @@ class TestSuiteSource(Source):
 
         return table
 
-    def _get_test_cases_from_test_suite(
-        self, test_suite: Optional[TestSuite]
-    ) -> List[TestCase]:
+    def _get_table_service_connection(self, table: Table) -> DatabaseConnection:
+        """Get the service connection for the table"""
+        service_name = table.service.name
+
+        if service_name not in self.service_connection_map:
+            try:
+                service: DatabaseService = self.metadata.get_by_name(
+                    DatabaseService, service_name
+                )
+                if not service:
+                    raise ConnectionError(
+                        f"Could not retrieve service with name `{service_name}`. "
+                        "Typically caused by the `entityFullyQualifiedName` does not exists in OpenMetadata "
+                        "or the JWT Token is invalid."
+                    )
+                if not service.connection:
+                    raise ConnectionError(
+                        f"Service with name `{service_name}` does not have a connection. "
+                        "If the connection is not stored in OpenMetadata, please provide it in the YAML file."
+                    )
+                self.service_connection_map[service_name] = service.connection
+
+            except Exception as exc:
+                logger.debug(traceback.format_exc())
+                logger.error(
+                    f"Error getting service connection for service name [{service_name}]"
+                    f" using the secrets manager provider [{self.metadata.config.secretsManagerProvider}]: {exc}"
+                )
+                raise exc
+
+        return self.service_connection_map[service_name]
+
+    def _get_test_cases_from_test_suite(self, test_suite: TestSuite) -> List[TestCase]:
         """Return test cases if the test suite exists and has them"""
-        if test_suite:
-            test_cases = self.metadata.list_all_entities(
-                entity=TestCase,
-                fields=["testSuite", "entityLink", "testDefinition"],
-                params={"testSuiteId": test_suite.id.root},
-            )
-            test_cases = cast(List[TestCase], test_cases)  # satisfy type checker
-            if self.source_config.testCases is not None:
-                test_cases = [
-                    t for t in test_cases if t.name in self.source_config.testCases
-                ]
-            return test_cases
-        return []
+        test_cases = self.metadata.list_all_entities(
+            entity=TestCase,
+            fields=["testSuite", "entityLink", "testDefinition"],
+            params={"testSuiteId": test_suite.id.root},
+        )
+        test_cases = cast(List[TestCase], test_cases)  # satisfy type checker
+        if self.source_config.testCases is not None:
+            test_cases = [
+                t for t in test_cases if t.name in self.source_config.testCases
+            ]
+        return test_cases
 
     def prepare(self):
         """Nothing to prepare"""
@@ -106,6 +158,7 @@ class TestSuiteSource(Source):
         self.metadata.health_check()
 
     def _iter(self) -> Iterable[Either[TableAndTests]]:
+        # Basic tests suites will have a table informed
         table: Table = self._get_table_entity()
         if table:
             source_type = table.serviceType.value.lower()
@@ -119,20 +172,29 @@ class TestSuiteSource(Source):
                 )
             yield from self._process_table_suite(table)
 
+        # Logical test suites won't have a table, we'll need to group the execution by tests
         else:
-            yield Either(
-                left=StackTraceError(
-                    name="Missing Table",
-                    error=f"Could not retrieve table entity for {self.source_config.entityFullyQualifiedName.root}."
-                    " Make sure the table exists in OpenMetadata and/or the JWT Token provided is valid.",
-                )
-            )
+            yield from self._process_logical_suite()
 
     def _process_table_suite(self, table: Table) -> Iterable[Either[TableAndTests]]:
         """
         Check that the table has the proper test suite built in
         """
+        try:
+            service_connection: DatabaseConnection = self._get_table_service_connection(
+                table
+            )
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name="Error getting service connection",
+                    error=f"Error getting the service connection for table {table.name.root}: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
+            return
         # If there is no executable test suite yet for the table, we'll need to create one
+        # Then, the suite won't have yet any tests
         if not table.testSuite:
             executable_test_suite = CreateTestSuiteRequest(
                 name=fqn.build(
@@ -143,38 +205,80 @@ class TestSuiteSource(Source):
                 displayName=f"{self.source_config.entityFullyQualifiedName.root} Test Suite",
                 description="Test Suite created from YAML processor config file",
                 owners=None,
-                executableEntityReference=self.source_config.entityFullyQualifiedName.root,
+                basicEntityReference=self.source_config.entityFullyQualifiedName.root,
             )
             yield Either(
                 right=TableAndTests(
                     executable_test_suite=executable_test_suite,
-                    service_type=self.config.source.serviceConnection.root.config.type.value,
+                    service_type=service_connection.config.type.value,
+                    service_connection=service_connection,
                 )
             )
+            test_suite_cases = []
 
-        test_suite: Optional[TestSuite] = None
-        if table.testSuite:
-            test_suite = self.metadata.get_by_id(
+        # Otherwise, we pick the tests already registered in the suite
+        else:
+            test_suite: Optional[TestSuite] = self.metadata.get_by_id(
                 entity=TestSuite, entity_id=table.testSuite.id.root
             )
+            test_suite_cases = self._get_test_cases_from_test_suite(test_suite)
+
+        yield Either(
+            right=TableAndTests(
+                table=table,
+                test_cases=test_suite_cases,
+                service_type=service_connection.config.type.value,
+                service_connection=service_connection,
+            )
+        )
 
-        if test_suite and not test_suite.executable:
+    def _process_logical_suite(self):
+        """Process logical test suite, collect all test cases and yield them in batches by table"""
+        test_suite = self.metadata.get_by_name(
+            entity=TestSuite, fqn=self.config.source.serviceName
+        )
+        if test_suite is None:
             yield Either(
                 left=StackTraceError(
-                    name="Non-executable Test Suite",
-                    error=f"The table {self.source_config.entityFullyQualifiedName.root} "
-                    "has a test suite that is not executable.",
+                    name="Test Suite not found",
+                    error=f"Test Suite with name {self.config.source.serviceName} not found",
                 )
             )
+        test_cases: List[TestCase] = self._get_test_cases_from_test_suite(test_suite)
+        grouped_by_table = itertools.groupby(
+            test_cases, key=lambda t: entity_link.get_table_fqn(t.entityLink.root)
+        )
+        for table_fqn, group in grouped_by_table:
+            table_entity: Table = self.metadata.get_by_name(Table, table_fqn)
+            if table_entity is None:
+                yield Either(
+                    left=StackTraceError(
+                        name="Table not found",
+                        error=f"Table with fqn {table_fqn} not found for test suite {test_suite.name.root}",
+                    )
+                )
+                continue
 
-        else:
-            test_suite_cases = self._get_test_cases_from_test_suite(test_suite)
+            try:
+                service_connection: DatabaseConnection = (
+                    self._get_table_service_connection(table_entity)
+                )
+            except Exception as exc:
+                yield Either(
+                    left=StackTraceError(
+                        name="Error getting service connection",
+                        error=f"Error getting the service connection for table {table_entity.name.root}: {exc}",
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+                continue
 
             yield Either(
                 right=TableAndTests(
-                    table=table,
-                    test_cases=test_suite_cases,
-                    service_type=self.config.source.serviceConnection.root.config.type.value,
+                    table=table_entity,
+                    test_cases=list(group),
+                    service_type=service_connection.config.type.value,
+                    service_connection=service_connection,
                 )
             )
 

metadata/generated/schema/analytics/__init__.py

@@ -1,3 +1,3 @@
 # generated by datamodel-codegen:
 #   filename:  schema
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00

metadata/generated/schema/analytics/basic.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/basic.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportDataType/__init__.py

@@ -1,3 +1,3 @@
 # generated by datamodel-codegen:
 #   filename:  schema
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00

metadata/generated/schema/analytics/reportDataType/aggregatedCostAnalysisReportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportDataType/aggregatedCostAnalysisReportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportDataType/entityReportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportDataType/entityReportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportDataType/rawCostAnalysisReportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportDataType/rawCostAnalysisReportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportDataType/webAnalyticEntityViewReportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportDataType/webAnalyticEntityViewReportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/reportDataType/webAnalyticUserActivityReportData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/reportDataType/webAnalyticUserActivityReportData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/webAnalyticEvent.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/webAnalyticEvent.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/webAnalyticEventData.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/webAnalyticEventData.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/webAnalyticEventType/__init__.py

@@ -1,3 +1,3 @@
 # generated by datamodel-codegen:
 #   filename:  schema
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00

metadata/generated/schema/analytics/webAnalyticEventType/customEvent.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/webAnalyticEventType/customEvent.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/analytics/webAnalyticEventType/pageViewEvent.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  analytics/webAnalyticEventType/pageViewEvent.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/api/__init__.py

@@ -1,3 +1,3 @@
 # generated by datamodel-codegen:
 #   filename:  schema
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00

metadata/generated/schema/api/addGlossaryToAssetsRequest.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  api/addGlossaryToAssetsRequest.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/api/addTagToAssetsRequest.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  api/addTagToAssetsRequest.json
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/api/analytics/__init__.py

@@ -1,3 +1,3 @@
 # generated by datamodel-codegen:
 #   filename:  schema
-#   timestamp: 2024-12-10T17:32:44+00:00
+#   timestamp: 2025-01-17T09:15:19+00:00