pycarlo 0.12.24__py3-none-any.whl

pycarlo/features/metadata/metadata_filters_container.py

@@ -0,0 +1,262 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Optional
+
+from dataclasses_json import dataclass_json
+
+from pycarlo.features.metadata import (
+    FilterEffectType,
+    FilterType,
+    MetadataAllowBlockList,
+    MetadataFilter,
+)
+
+
+@dataclass_json
+@dataclass
+class MetadataFiltersContainer:
+    """
+    More documentation and samples in the link below:
+    https://www.notion.so/montecarlodata/Catalog-Schema-Filtering-59edd6eff7f74c94ab6bfca75d2e3ff1
+
+    MetadataFiltersContainer class that includes a metadata_filters list that works
+    in the following way:
+    A list of filters where:
+    - each filter can be a block or allow filter
+    - each filter can optionally filter: project, dataset, table and table_type
+    - each filter matches using of the following types: exact match, regular expression, prefix
+    - there's a default effect (allow/block) configured in the list, those elements with no matching
+      filter will be resolved with the default effect in the list.
+    - This class supports filtering objects in memory or generating SQL conditions for filtering,
+      for SQL generation an encoder function is required that maps the different filter types to
+      SQL, also a dictionary mapping from property name to column name is required (for example to
+      map 'project' to 'database' or 'dataset' to 'schema'.
+    - The order in which elements are added to the list is not relevant, priority is assigned based
+      on the effect, rules with the default effect have the higher priority and stop the iteration.
+
+    Filtering works by prioritizing "explicit" filters, a filter is considered explicit when it is
+    configured with the same effect used as the default in the list.
+    Let's suppose we have the following sample data:
+    - prj_1: ds_1, ds_2
+    - prj_2: ds_1, ds_2, ds_3
+    - project_3: dataset_1, ds_2
+    _ project_4: dataset_4
+
+    These are examples using the sample data above:
+    - list(default=allow): block(prj_*), allow(prj_1)
+        - will allow prj_1 and all those projects not matching prj_*
+        - allowed: (prj_1, all datasets), (project_3, all datasets), (project_4, all datasets)
+    - list(default=block): allow(prj_*), block(prj_1)
+        - will allow only prj_* except prj_1 that is explicitly blocked
+        - allowed: (prj_2, all datasets)
+    - list(default=allow): allow(*), block(prj_1)
+        - will allow everything, allow(*) is considered a explicit rule and has the highest priority
+        - allowed: everything
+    - list(default=allow): block(*), allow(prj_1)
+        - will allow only prj_1
+        - allowed: (prj_1, all datasets)
+    - list(default=allow): block(*, ds_*)
+        - will block all datasets named ds_*
+        - allowed: (project_3, dataset_1), (project_4, all datasets)
+    - list(default=allow): allow(prj_2, ds_3), block(*, ds_*)
+        - will block all datasets named ds_3 except for ds_3 in prj_2 that is explicitly allowed.
+          Please note order is not relevant and the result would be exactly the same for:
+            block(*, ds_*), allow(prj_2, ds_3)
+        - allowed: (prj_2, ds_3), (project_3, dataset_1), (project_4, all datasets)
+    - list(default=block): allow(*, dataset_*):
+        - only datasets named dataset_* will be allowed
+        - allowed: (project_3, dataset_1), (project_4, dataset_4)
+    """
+
+    metadata_filters: MetadataAllowBlockList = field(default_factory=MetadataAllowBlockList)
+
+    @property
+    def is_metadata_filtered(self) -> bool:
+        return bool(self.metadata_filters.filters)
+
+    @property
+    def is_metadata_blocked(self):
+        """
+        Helper method for detecting an edge case where everything is blocked because the default
+        effect is block and all filters are also blocking, in this case it doesn't make sense to
+        run queries or filter data.
+        """
+        return self.metadata_filters.default_effect == FilterEffectType.BLOCK and all(
+            f.effect == FilterEffectType.BLOCK for f in self.metadata_filters.filters
+        )
+
+    def is_project_with_datasets_filtered(self, project: str) -> bool:
+        """
+        Returns True if there's at least one filter configured for the specified project filtering
+        on datasets, this can be used to check if get_sql_conditions for the project is going to
+        return an empty query or not.
+        """
+        return self.is_metadata_filtered and any(
+            f.matches(project=project) and f.dataset is not None
+            for f in self.metadata_filters.filters
+        )
+
+    def is_whole_project_blocked(self, project: str) -> bool:
+        """
+        Helper method to be used when projects are iterated first, returns True if the project is
+        fully blocked (blocked by a filter with no dataset or blocked by default) False otherwise.
+        For example for a list like: list(default=allow): block(prj_1, ds_1) this method will return
+        False as prj_1 is not fully blocked, there might be a (prj_1, ds_2) that is allowed, so
+        prj_1 still needs to be iterated.
+        """
+        # the condition parameter below is to include blocking filters only if applied to the
+        # whole project, we don't want to exclude a project just because a dataset is excluded
+        effect = self._get_effect(
+            metadata_filters=self.metadata_filters,
+            force_regexp=False,
+            condition=lambda f: not f.dataset or f.effect == FilterEffectType.ALLOW,
+            project=project,
+        )
+        return effect == FilterEffectType.BLOCK
+
+    def is_metadata_element_allowed(self, **kwargs: Any) -> bool:
+        """
+        Metadata elements filtering, iterates all filters looking for a match, if there's
+        a match in a filter with the default effect, it's considered an explicit filter
+        and search stops with the result effect being the default one.
+        If there's a match in a filter not configured with the default effect, search continues.
+        When the search completes, if there was a match then the result effect will be the one in
+        the matched filter (must be the non-default effect).
+        If there was no match the result effect will be the default one.
+        Result for this method is True only if the result effect is ALLOW.
+
+        Data is matched using properties specified in kwargs, the following keys are supported
+        in kwargs: 'project', 'dataset', 'table', 'table_type'.
+        """
+        effect = self._get_effect(
+            metadata_filters=self.metadata_filters, force_regexp=False, **kwargs
+        )
+        return effect == FilterEffectType.ALLOW
+
+    @staticmethod
+    def _get_effect(
+        metadata_filters: MetadataAllowBlockList,
+        force_regexp: bool,
+        condition: Optional[Callable[[MetadataFilter], bool]] = None,
+        **kwargs: Any,
+    ) -> FilterEffectType:
+        """
+        Returns the effect for a metadata element with the properties specified by kwargs
+        (project, dataset, table, table_type).
+        If there's an explicit filter matching (a filter is explicit if the effect is the default
+        one) then default effect is returned.
+        If there's a match in the "other effect" list then the "other effect" is returned, we're
+        calling "other effect" to the effect that is not the default one.
+        If no matching filter, the default effect is returned.
+        """
+        if not metadata_filters.filters or any(
+            f.matches(force_regexp, **kwargs)
+            for f in metadata_filters.get_default_effect_rules(condition=condition)
+        ):
+            return metadata_filters.default_effect
+
+        if any(
+            f.matches(force_regexp, **kwargs)
+            for f in metadata_filters.get_other_effect_rules(condition=condition)
+        ):
+            return metadata_filters.other_effect
+
+        return metadata_filters.default_effect
+
+    def is_dataset_allowed(self, project: Optional[str], dataset: str) -> bool:
+        """
+        Helper method intended to be used when projects and datasets are iterated in memory.
+        It returns True if the dataset in the given project is allowed (not blocked), this is
+        equivalent to call is_metadata_element_allowed(project=project, dataset=dataset)
+        """
+        return self.is_metadata_element_allowed(project=project, dataset=dataset)
+
+    def get_sql_conditions(
+        self,
+        column_mapping: Dict,  # maps project and dataset to the column name to use
+        encoder: Callable[[str, str, FilterType], str],
+        project: Optional[str] = None,
+        force_lowercase: Optional[bool] = True,
+    ) -> Optional[str]:
+        """
+        Helper method that returns a SQL query fragment with conditions for the current filters.
+        If project is specified this will return conditions only for the specified project and this
+        is supposed to be called after checking that is_project_with_datasets_filtered and
+        is_project_allowed returned True.
+        column_mapping is used to map filter fields (like project and dataset) to the actual
+        database columns (like database and schema).
+        encoder is used to encode a filter in the SQL dialect, it needs to encode to expressions
+        like "database = 'db_1'" or "database REGEXP 'db_.*'".
+        Examples:
+            - default=block, filters=allow(project=x_*), block(project=x_1), allow(project=z)
+                SQL: NOT(project='x_1') AND ((project REGEXP 'x_*') OR (project='z')
+            - default=allow, filters=block(project=x_*), allow(project=x_1), block(project=z)
+                SQL: project='x_1' OR (NOT(project REGEXP 'x_*') AND NOT(project='z'))
+        Basically we first put all filters matching the default condition joined by
+        AND/OR (block/allow), and then all filters with the other effect joined by OR/AND.
+        """
+        if not self.metadata_filters.filters:
+            return None
+        if project and not self.is_project_with_datasets_filtered(project):
+            return None
+
+        def project_condition(f: MetadataFilter):
+            return not project or f.matches(project=project)
+
+        default_effect = self.metadata_filters.default_effect
+        default_effect_filters = self.metadata_filters.get_default_effect_rules(
+            condition=project_condition
+        )
+        other_effect_filters = self.metadata_filters.get_other_effect_rules(
+            condition=project_condition
+        )
+        default_effect_op = " OR " if default_effect == FilterEffectType.ALLOW else " AND "
+        other_effect_op = " AND " if default_effect == FilterEffectType.ALLOW else " OR "
+
+        default_effect_conditions = default_effect_op.join(
+            [
+                self._get_sql_field_condition(f, column_mapping, encoder, force_lowercase)
+                for f in default_effect_filters
+            ]
+        )
+        other_effect_conditions = other_effect_op.join(
+            [
+                self._get_sql_field_condition(f, column_mapping, encoder, force_lowercase)
+                for f in other_effect_filters
+            ]
+        )
+
+        if default_effect_conditions and other_effect_conditions:
+            return f"(({default_effect_conditions}){default_effect_op}({other_effect_conditions}))"
+        elif default_effect_conditions:
+            return f"({default_effect_conditions})"
+        elif other_effect_conditions:
+            return f"({other_effect_conditions})"
+        else:
+            return None
+
+    @staticmethod
+    def _get_sql_field_condition(
+        mf: MetadataFilter,
+        column_mapping: Dict,
+        encoder: Callable[[str, str, FilterType], str],
+        force_lowercase: Optional[bool] = True,
+    ) -> str:
+        # The comparison is performed case-insensitive (check MetadataFilter._safe_match)
+        # We can use LOWER here since it is part of standard SQL (like AND/OR/NOT), so including it
+        # here is a way to make sure that all comparisons are case-insensitive in the SQL sentences
+        # for all engines. Added option to not always LOWER since customers do have lower/upper case
+        # databases logged in MC
+        conditions = " AND ".join(
+            [
+                encoder(
+                    f"LOWER({column})" if force_lowercase else column,
+                    getattr(mf, field).lower() if force_lowercase else getattr(mf, field),
+                    mf.type if field == mf.filter_type_target_field() else FilterType.EXACT_MATCH,
+                )
+                for (field, column) in column_mapping.items()
+                if getattr(mf, field) is not None
+            ]
+        )
+        if not conditions:
+            return ""
+        return f"NOT({conditions})" if mf.effect == FilterEffectType.BLOCK else f"({conditions})"

pycarlo/features/pii/__init__.py

@@ -0,0 +1,5 @@
+from pycarlo.features.pii.constants import PiiFilteringFailModeType
+from pycarlo.features.pii.pii_filterer import PiiFilterer
+from pycarlo.features.pii.service import PiiService
+
+__all__ = ["PiiFilteringFailModeType", "PiiService", "PiiFilterer"]

pycarlo/features/pii/constants.py

@@ -0,0 +1,3 @@
+class PiiFilteringFailModeType:
+    OPEN = "OPEN"
+    CLOSE = "CLOSE"

pycarlo/features/pii/pii_filterer.py

@@ -0,0 +1,179 @@
+import logging
+import re
+import time
+from dataclasses import dataclass
+from re import Pattern
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from dataclasses_json import dataclass_json
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass_json
+@dataclass
+class PiiActiveFilter:
+    name: str
+    pattern: str
+
+
+@dataclass_json
+@dataclass
+class PiiActiveFiltersConfig:
+    active: List[PiiActiveFilter]
+    fail_closed: bool = True
+
+    @staticmethod
+    def is_valid_config(cfg: Optional[Dict]) -> bool:
+        return bool(cfg and cfg.get("active", []))
+
+
+@dataclass_json
+@dataclass
+class PiiFilterMetrics:
+    replacements: int
+    time_taken_ms: float
+
+
+@dataclass
+class PiiCompiledFilter:
+    name: str
+    compiled_expression: Pattern
+    replacement: str
+
+
+class PiiFilterer:
+    _TOTAL_KEY = "_total"
+    _REPLACEMENT_STRING = "<filtered:{}>"
+
+    def __init__(self, filters_config: Optional[Dict], include_metrics: bool = True):
+        self._config = (
+            PiiActiveFiltersConfig.from_dict(filters_config)  # type: ignore
+            if PiiActiveFiltersConfig.is_valid_config(filters_config)
+            else None
+        )
+
+        if self._config:
+            self._filters = [
+                PiiCompiledFilter(
+                    name=f.name,
+                    compiled_expression=re.compile(f.pattern),
+                    replacement=self._REPLACEMENT_STRING.format(f.name),
+                )
+                for f in self._config.active
+            ]
+        self._include_metrics = include_metrics
+
+    @staticmethod
+    def _metrics_to_final(metrics: Dict, elapsed_time_ns: int) -> Dict:
+        final_metrics = {
+            k: PiiFilterMetrics(replacements=v, time_taken_ms=t / 1000000).to_dict()  # type: ignore
+            for k, (v, t) in metrics.items()
+        }
+        total_replacements = sum(m["replacements"] for m in final_metrics.values())
+
+        final_metrics[PiiFilterer._TOTAL_KEY] = PiiFilterMetrics(
+            replacements=total_replacements, time_taken_ms=elapsed_time_ns / 1000000
+        ).to_dict()  # type: ignore
+
+        return final_metrics
+
+    def filter_content(self, content: Union[bytes, str, Dict]) -> Union[bytes, str, Dict]:
+        """
+        Utility method to filter one of bytes, str or Dict. Calls internally one of:
+        - filter_data
+        - filter_str
+        - filter_message
+        """
+        if isinstance(content, dict):
+            return self.filter_message(content)
+        elif isinstance(content, str):
+            return self.filter_str(content)
+        else:
+            return self.filter_data(content)
+
+    def filter_message(self, msg: Union[bytes, str, Dict]) -> Union[bytes, str, Dict]:
+        """
+        Filters a dictionary or a list. If the object is a dictionary it includes metrics in a
+        pii_metrics attribute in the result dictionary (only if the filterer was created with
+        include_metrics=True which is the default value).
+        """
+        if not self._config:
+            return msg
+
+        start_time = time.time_ns()
+
+        include_metrics = self._include_metrics and isinstance(msg, Dict)
+        metrics = {} if include_metrics else None
+
+        result = self._do_filter(msg, lambda o: self._filter_object(o, metrics=metrics))
+
+        if include_metrics:
+            assert metrics is not None
+            elapsed_time = time.time_ns() - start_time
+            result["pii_metrics"] = self._metrics_to_final(metrics, elapsed_time_ns=elapsed_time)
+
+        return result
+
+    def _do_filter(self, data: Any, filter_function: Callable[[Any], Any]) -> Any:
+        if not self._config:
+            return data
+        try:
+            result = filter_function(data)
+        except Exception as exc:
+            if self._config.fail_closed:
+                raise
+            _logger.exception(
+                f"Failed to evaluate PII filters: {exc}, ignoring because fail_closed=False"
+            )
+            result = data
+        return result
+
+    def filter_str(self, msg: str) -> str:
+        """
+        Filters a string, please note metrics are not included as we don't have a way to include
+        metrics in the resulting string. We might return metrics in the future if we decide to
+        use them where we call this (dbtv2 collection)
+        """
+        return self._do_filter(msg, lambda o: self._filter_text(o))
+
+    def filter_data(self, msg: bytes, encoding: str = "utf8") -> bytes:
+        """
+        Filters a bytes array using the given encoding, please note metrics are not included as
+        we don't have a way to include metrics in the resulting bytes array. We might return metrics
+        in the future if we decide to use them where we call this (dbtv2 collection)
+        """
+        return self._do_filter(msg, lambda o: self._filter_bytes(o, encoding=encoding))
+
+    def _filter_bytes(self, data: bytes, encoding: str) -> bytes:
+        text = data.decode(encoding)
+        filtered_text = self._filter_text(text)
+        return filtered_text.encode(encoding)
+
+    def _filter_object(self, o: Any, metrics: Optional[Dict] = None) -> Any:
+        if isinstance(o, Dict):
+            return {
+                self._filter_text(k, metrics=metrics): self._filter_object(v, metrics=metrics)
+                for k, v in o.items()
+            }
+        elif isinstance(o, List):
+            return [self._filter_object(e, metrics=metrics) for e in o]
+        elif isinstance(o, tuple):
+            return tuple(self._filter_object(e, metrics=metrics) for e in o)
+        elif isinstance(o, str):
+            return self._filter_text(o, metrics=metrics)
+        else:
+            return o
+
+    def _filter_text(self, text: str, metrics: Optional[Dict] = None) -> str:
+        for f in self._filters:
+            filter_name = f.name
+            start_time = time.time_ns()
+            text, updated_count = f.compiled_expression.subn(f.replacement, text)
+            elapsed_time = time.time_ns() - start_time
+
+            if metrics is not None:
+                prev_count, prev_time = metrics.get(filter_name, (0, 0))
+                metrics[filter_name] = (prev_count + updated_count, prev_time + elapsed_time)
+
+        return text

pycarlo/features/pii/queries.py

@@ -0,0 +1,20 @@
+# Queries related to PII Filtering
+
+GET_PII_PREFERENCES = """
+query getPiiFilteringPreferences {
+  getPiiFilteringPreferences {
+    enabled,
+    failMode
+  }
+}
+"""
+
+GET_PII_FILTERS = """
+query getPiiFilters {
+  getPiiFilters {
+    name,
+    pattern,
+    enabled
+  }
+}
+"""

pycarlo/features/pii/service.py

@@ -0,0 +1,56 @@
+from typing import Dict, Optional, cast
+
+from pycarlo.common.settings import (
+    HEADER_MCD_TELEMETRY_REASON,
+    HEADER_MCD_TELEMETRY_SERVICE,
+    RequestReason,
+)
+from pycarlo.core import Client, Query
+from pycarlo.features.pii import PiiFilteringFailModeType
+from pycarlo.features.pii.pii_filterer import PiiActiveFilter, PiiActiveFiltersConfig
+from pycarlo.features.pii.queries import GET_PII_FILTERS, GET_PII_PREFERENCES
+
+
+class PiiService:
+    def __init__(self, mc_client: Optional[Client] = None):
+        self._mc_client = mc_client or Client()
+
+    def get_pii_filters_config(self) -> Optional[Dict]:
+        prefs = cast(
+            Query,
+            self._mc_client(
+                query=GET_PII_PREFERENCES,
+                additional_headers={
+                    HEADER_MCD_TELEMETRY_REASON: RequestReason.SERVICE.value,
+                    HEADER_MCD_TELEMETRY_SERVICE: "pii_service",
+                },
+            ),
+        ).get_pii_filtering_preferences
+        if not prefs.enabled:
+            return None
+
+        fail_closed = prefs.fail_mode.upper() == PiiFilteringFailModeType.CLOSE
+        pii_filters = cast(
+            Query,
+            self._mc_client(
+                query=GET_PII_FILTERS,
+                additional_headers={
+                    HEADER_MCD_TELEMETRY_REASON: RequestReason.SERVICE.value,
+                    HEADER_MCD_TELEMETRY_SERVICE: "pii_service",
+                },
+            ),
+        ).get_pii_filters
+        if not pii_filters:
+            return None
+
+        return PiiActiveFiltersConfig(
+            fail_closed=fail_closed,
+            active=[
+                PiiActiveFilter(
+                    name=cast(str, f.name),
+                    pattern=cast(str, f.pattern),
+                )
+                for f in pii_filters
+                if f.enabled
+            ],
+        ).to_dict()  # type: ignore

pycarlo/features/user/__init__.py

@@ -0,0 +1,4 @@
+from pycarlo.features.user.models import Resource
+from pycarlo.features.user.service import UserService
+
+__all__ = ["Resource", "UserService"]

pycarlo/features/user/exceptions.py

@@ -0,0 +1,10 @@
+class UserServiceException(Exception):
+    pass
+
+
+class ResourceNotFoundException(UserServiceException):
+    pass
+
+
+class MultipleResourcesFoundException(UserServiceException):
+    pass

pycarlo/features/user/models.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from uuid import UUID
+
+
+@dataclass
+class Resource:
+    id: UUID
+    name: str
+    type: str

pycarlo/features/user/queries.py

@@ -0,0 +1,13 @@
+GET_USER_WAREHOUSES = """
+query getUserWarehouses {
+  getUser {
+    account {
+      warehouses {
+        uuid
+        name
+        connectionType
+      }
+    }
+  }
+}
+"""

pycarlo/features/user/service.py

@@ -0,0 +1,71 @@
+from typing import Optional, Union, cast
+from uuid import UUID
+
+from pycarlo.common.settings import (
+    HEADER_MCD_TELEMETRY_REASON,
+    HEADER_MCD_TELEMETRY_SERVICE,
+    RequestReason,
+)
+from pycarlo.core import Client, Query
+from pycarlo.features.user.exceptions import (
+    MultipleResourcesFoundException,
+    ResourceNotFoundException,
+)
+from pycarlo.features.user.models import Resource
+from pycarlo.features.user.queries import GET_USER_WAREHOUSES
+
+
+class UserService:
+    def __init__(self, mc_client: Optional[Client] = None):
+        self._mc_client = mc_client or Client()
+
+    def get_resource(self, resource_id: Optional[Union[str, UUID]] = None) -> Resource:
+        """
+        Get a resource (e.g. lake or warehouse).
+
+        :param resource_id: resource identifier. If not provided, and your account only has one
+                            resource, it will be returned. If your account has multiple resources
+                            an exception will be raised indicating a a resource id must be provided.
+
+        :return: resource (e.g. lake or warehouse monitored by Monte Carlo)
+        :raise MultipleResourcesFoundException: multiple resources
+                                                exist (a `resource_id` must be provided)
+        :raise ResourceNotFoundException: a resource could not be found
+        """
+        response = cast(
+            Query,
+            self._mc_client(
+                query=GET_USER_WAREHOUSES,
+                additional_headers={
+                    HEADER_MCD_TELEMETRY_REASON: RequestReason.SERVICE.value,
+                    HEADER_MCD_TELEMETRY_SERVICE: "user_service",
+                },
+            ),
+        )
+        warehouses = response.get_user.account.warehouses
+
+        # if resource id was provided, look for matching warehouse record
+        if resource_id:
+            for w in warehouses:
+                if w.uuid == str(resource_id):
+                    return Resource(
+                        id=UUID(w.uuid),  # type: ignore
+                        name=w.name,  # type: ignore[reportArgumentType]
+                        type=w.connection_type,  # type: ignore[reportArgumentType]
+                    )
+
+            # resource not found
+            raise ResourceNotFoundException(f"Resource not found with id={resource_id}")
+
+        # if only one warehouse exists, return it
+        if len(warehouses) == 1:
+            return Resource(
+                id=UUID(warehouses[0].uuid),  # type: ignore
+                name=warehouses[0].name,  # type: ignore[reportArgumentType]
+                type=warehouses[0].connection_type,  # type: ignore[reportArgumentType]
+            )
+        # otherwise, raise an error requesting a resource id
+        else:
+            raise MultipleResourcesFoundException(
+                "Multiple resources found, please specify a resource id"
+            )

pycarlo/lib/README.md

@@ -0,0 +1,35 @@
+# Monte Carlo GraphQL Schema Library
+
+The `schema.json` and `schema.py` files are auto-generated. **Do not edit them directly**!
+
+If you need to customize the schema, see below. Refer to the
+[CONTRIBUTING.md](../../CONTRIBUTING.md) for general development guidelines.
+
+## Schema Customizations
+
+The generated `schema.py` is automatically modified during the build process to apply the following
+customizations. This is done via `sed` commands in the [Makefile](../../Makefile), but if we need to
+get fancier, we just can update the `customize-schema` target there to call whatever we need to do.
+
+### Connection Type Fix
+
+The `Connection` class is changed from `sgqlc.types.relay.Connection` to `sgqlc.types.Type`.
+
+**Why:** sgqlc automatically makes all types ending in "Connection" inherit from `relay.Connection`,
+which makes `Connection` not a valid field type. This causes requests to fail when attempting to
+resolve it. Changing it to inherit from `sgqlc.types.Type` fixes this issue.
+
+[Related PR](https://github.com/monte-carlo-data/python-sdk/pull/63)
+
+### Backward-Compatible Enums
+
+All GraphQL enum types use `pycarlo.lib.types.Enum` instead of `sgqlc.types.Enum`. This custom enum
+class gracefully handles unknown enum values by returning them as strings instead of raising errors.
+
+**Why:** When new enum values are added to the Monte Carlo API, older SDK versions would crash when
+deserializing responses containing these new values. Our custom Enum prevents this by:
+
+- Returning unknown values as plain strings (same type as known values)
+- Logging a warning when unknown values are encountered
+
+See [pycarlo/lib/types.py](types.py) for implementation details.