mlrun 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

mlrun/common/schemas/model_endpoints.py

@@ -0,0 +1,342 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import enum
+import json
+import typing
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from pydantic import BaseModel, Field
+from pydantic.main import Extra
+
+import mlrun.common.model_monitoring
+from mlrun.common.schemas.object import ObjectKind, ObjectSpec, ObjectStatus
+
+
+class ModelMonitoringStoreKinds:
+    # TODO: do changes in examples & demos In 1.5.0 remove
+    ENDPOINTS = "endpoints"
+    EVENTS = "events"
+
+
+class ModelEndpointMetadata(BaseModel):
+    project: Optional[str] = ""
+    labels: Optional[dict] = {}
+    uid: Optional[str] = ""
+
+    class Config:
+        extra = Extra.allow
+
+    @classmethod
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+        """Create a `ModelEndpointMetadata` object from an endpoint dictionary
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
+                                  dictionary using json.loads().
+        """
+        new_object = cls()
+        if json_parse_values is None:
+            json_parse_values = [mlrun.common.model_monitoring.EventFieldType.LABELS]
+
+        return _mapping_attributes(
+            base_model=new_object,
+            flattened_dictionary=endpoint_dict,
+            json_parse_values=json_parse_values,
+        )
+
+
+class ModelEndpointSpec(ObjectSpec):
+    function_uri: Optional[str] = ""  # <project_name>/<function_name>:<tag>
+    model: Optional[str] = ""  # <model_name>:<version>
+    model_class: Optional[str] = ""
+    model_uri: Optional[str] = ""
+    feature_names: Optional[List[str]] = []
+    label_names: Optional[List[str]] = []
+    stream_path: Optional[str] = ""
+    algorithm: Optional[str] = ""
+    monitor_configuration: Optional[dict] = {}
+    active: Optional[bool] = True
+    monitoring_mode: Optional[
+        mlrun.common.model_monitoring.ModelMonitoringMode
+    ] = mlrun.common.model_monitoring.ModelMonitoringMode.disabled.value
+
+    @classmethod
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+        """Create a `ModelEndpointSpec` object from an endpoint dictionary
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
+                                  dictionary using json.loads().
+        """
+        new_object = cls()
+        if json_parse_values is None:
+            json_parse_values = [
+                mlrun.common.model_monitoring.EventFieldType.FEATURE_NAMES,
+                mlrun.common.model_monitoring.EventFieldType.LABEL_NAMES,
+                mlrun.common.model_monitoring.EventFieldType.MONITOR_CONFIGURATION,
+            ]
+        return _mapping_attributes(
+            base_model=new_object,
+            flattened_dictionary=endpoint_dict,
+            json_parse_values=json_parse_values,
+        )
+
+
+class Histogram(BaseModel):
+    buckets: List[float]
+    counts: List[int]
+
+
+class FeatureValues(BaseModel):
+    min: float
+    mean: float
+    max: float
+    histogram: Histogram
+
+    @classmethod
+    def from_dict(cls, stats: Optional[dict]):
+        if stats:
+            return FeatureValues(
+                min=stats["min"],
+                mean=stats["mean"],
+                max=stats["max"],
+                histogram=Histogram(buckets=stats["hist"][1], counts=stats["hist"][0]),
+            )
+        else:
+            return None
+
+
+class Features(BaseModel):
+    name: str
+    weight: float
+    expected: Optional[FeatureValues]
+    actual: Optional[FeatureValues]
+
+    @classmethod
+    def new(
+        cls,
+        feature_name: str,
+        feature_stats: Optional[dict],
+        current_stats: Optional[dict],
+    ):
+        return cls(
+            name=feature_name,
+            weight=-1.0,
+            expected=FeatureValues.from_dict(feature_stats),
+            actual=FeatureValues.from_dict(current_stats),
+        )
+
+
+class ModelEndpointStatus(ObjectStatus):
+    feature_stats: Optional[dict] = {}
+    current_stats: Optional[dict] = {}
+    first_request: Optional[str] = ""
+    last_request: Optional[str] = ""
+    error_count: Optional[int] = 0
+    drift_status: Optional[str] = ""
+    drift_measures: Optional[dict] = {}
+    metrics: Optional[Dict[str, Dict[str, Any]]] = {
+        mlrun.common.model_monitoring.EventKeyMetrics.GENERIC: {
+            mlrun.common.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
+            mlrun.common.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
+        }
+    }
+    features: Optional[List[Features]] = []
+    children: Optional[List[str]] = []
+    children_uids: Optional[List[str]] = []
+    endpoint_type: Optional[
+        mlrun.common.model_monitoring.EndpointType
+    ] = mlrun.common.model_monitoring.EndpointType.NODE_EP.value
+    monitoring_feature_set_uri: Optional[str] = ""
+    state: Optional[str] = ""
+
+    class Config:
+        extra = Extra.allow
+
+    @classmethod
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+        """Create a `ModelEndpointStatus` object from an endpoint dictionary
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
+                                  dictionary using json.loads().
+        """
+        new_object = cls()
+        if json_parse_values is None:
+            json_parse_values = [
+                mlrun.common.model_monitoring.EventFieldType.FEATURE_STATS,
+                mlrun.common.model_monitoring.EventFieldType.CURRENT_STATS,
+                mlrun.common.model_monitoring.EventFieldType.DRIFT_MEASURES,
+                mlrun.common.model_monitoring.EventFieldType.METRICS,
+                mlrun.common.model_monitoring.EventFieldType.CHILDREN,
+                mlrun.common.model_monitoring.EventFieldType.CHILDREN_UIDS,
+                mlrun.common.model_monitoring.EventFieldType.ENDPOINT_TYPE,
+            ]
+        return _mapping_attributes(
+            base_model=new_object,
+            flattened_dictionary=endpoint_dict,
+            json_parse_values=json_parse_values,
+        )
+
+
+class ModelEndpoint(BaseModel):
+    kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
+    metadata: ModelEndpointMetadata = ModelEndpointMetadata()
+    spec: ModelEndpointSpec = ModelEndpointSpec()
+    status: ModelEndpointStatus = ModelEndpointStatus()
+
+    class Config:
+        extra = Extra.allow
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        if self.metadata.uid is None:
+            uid = mlrun.common.model_monitoring.create_model_endpoint_uid(
+                function_uri=self.spec.function_uri,
+                versioned_model=self.spec.model,
+            )
+            self.metadata.uid = str(uid)
+
+    def flat_dict(self):
+        """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
+        the model endpoint object in the database.
+
+        :return: Flattened `ModelEndpoint` dictionary.
+        """
+        # Convert the ModelEndpoint object into a dictionary using BaseModel dict() function
+        # In addition, remove the BaseModel kind as it is not required by the DB schema
+        model_endpoint_dictionary = self.dict(exclude={"kind"})
+
+        # Initialize a flattened dictionary that will be filled with the model endpoint dictionary attributes
+        flatten_dict = {}
+        for k_object in model_endpoint_dictionary:
+            for key in model_endpoint_dictionary[k_object]:
+                # Extract the value of the current field
+                current_value = model_endpoint_dictionary[k_object][key]
+
+                # If the value is not from type str or bool (e.g. dict), convert it into a JSON string
+                # for matching the database required format
+                if not isinstance(current_value, (str, bool, int)) or isinstance(
+                    current_value, enum.IntEnum
+                ):
+                    flatten_dict[key] = json.dumps(current_value)
+                else:
+                    flatten_dict[key] = current_value
+
+        if mlrun.common.model_monitoring.EventFieldType.METRICS not in flatten_dict:
+            # Initialize metrics dictionary
+            flatten_dict[mlrun.common.model_monitoring.EventFieldType.METRICS] = {
+                mlrun.common.model_monitoring.EventKeyMetrics.GENERIC: {
+                    mlrun.common.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
+                    mlrun.common.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
+                }
+            }
+
+        # Remove the features from the dictionary as this field will be filled only within the feature analysis process
+        flatten_dict.pop(mlrun.common.model_monitoring.EventFieldType.FEATURES, None)
+        return flatten_dict
+
+    @classmethod
+    def from_flat_dict(cls, endpoint_dict: dict):
+        """Create a `ModelEndpoint` object from an endpoint flattened dictionary. Because the provided dictionary
+        is flattened, we pass it as is to the subclasses without splitting the keys into spec, metadata, and status.
+
+        :param endpoint_dict:     Model endpoint dictionary.
+        """
+
+        return cls(
+            metadata=ModelEndpointMetadata.from_flat_dict(endpoint_dict=endpoint_dict),
+            spec=ModelEndpointSpec.from_flat_dict(endpoint_dict=endpoint_dict),
+            status=ModelEndpointStatus.from_flat_dict(endpoint_dict=endpoint_dict),
+        )
+
+
+class ModelEndpointList(BaseModel):
+    endpoints: List[ModelEndpoint] = []
+
+
+class GrafanaColumn(BaseModel):
+    text: str
+    type: str
+
+
+class GrafanaNumberColumn(GrafanaColumn):
+    text: str
+    type: str = "number"
+
+
+class GrafanaStringColumn(GrafanaColumn):
+    text: str
+    type: str = "string"
+
+
+class GrafanaTable(BaseModel):
+    columns: List[GrafanaColumn]
+    rows: List[List[Optional[Union[float, int, str]]]] = []
+    type: str = "table"
+
+    def add_row(self, *args):
+        self.rows.append(list(args))
+
+
+class GrafanaDataPoint(BaseModel):
+    value: float
+    timestamp: int  # Unix timestamp in milliseconds
+
+
+class GrafanaTimeSeriesTarget(BaseModel):
+    target: str
+    datapoints: List[Tuple[float, int]] = []
+
+    def add_data_point(self, data_point: GrafanaDataPoint):
+        self.datapoints.append((data_point.value, data_point.timestamp))
+
+
+def _mapping_attributes(
+    base_model: BaseModel,
+    flattened_dictionary: dict,
+    json_parse_values: typing.List = None,
+):
+    """Generate a `BaseModel` object with the provided dictionary attributes.
+
+    :param base_model:           `BaseModel` object (e.g. `ModelEndpointMetadata`).
+    :param flattened_dictionary: Flattened dictionary that contains the model endpoint attributes.
+    :param json_parse_values:    List of dictionary keys with a JSON string value that will be parsed into a
+                                 dictionary using json.loads().
+    """
+    # Get the fields of the provided base model object. These fields will be used to filter to relevent keys
+    # from the flattened dictionary.
+    wanted_keys = base_model.__fields__.keys()
+
+    # Generate a filtered flattened dictionary that will be parsed into the BaseModel object
+    dict_to_parse = {}
+    for field_key in wanted_keys:
+        if field_key in flattened_dictionary:
+            if field_key in json_parse_values:
+                # Parse the JSON value into a valid dictionary
+                dict_to_parse[field_key] = _json_loads_if_not_none(
+                    flattened_dictionary[field_key]
+                )
+            else:
+                dict_to_parse[field_key] = flattened_dictionary[field_key]
+
+    return base_model.parse_obj(dict_to_parse)
+
+
+def _json_loads_if_not_none(field: Any) -> Any:
+    return (
+        json.loads(field) if field and field != "null" and field is not None else None
+    )

mlrun/common/schemas/notification.py

@@ -0,0 +1,57 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+import typing
+
+import pydantic
+
+import mlrun.common.types
+
+
+class NotificationKind(mlrun.common.types.StrEnum):
+    console = "console"
+    git = "git"
+    ipython = "ipython"
+    slack = "slack"
+
+
+class NotificationSeverity(mlrun.common.types.StrEnum):
+    INFO = "info"
+    DEBUG = "debug"
+    VERBOSE = "verbose"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+class NotificationStatus(mlrun.common.types.StrEnum):
+    PENDING = "pending"
+    SENT = "sent"
+    ERROR = "error"
+
+
+class Notification(pydantic.BaseModel):
+    kind: NotificationKind
+    name: str
+    message: str
+    severity: NotificationSeverity
+    when: typing.List[str]
+    condition: str
+    params: typing.Dict[str, typing.Any] = None
+    status: NotificationStatus = None
+    sent_time: typing.Union[str, datetime.datetime] = None
+
+
+class SetNotificationRequest(pydantic.BaseModel):
+    notifications: typing.List[Notification] = None

mlrun/{api → common}/schemas/object.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@ from typing import List, Optional
 
 from pydantic import BaseModel, Extra
 
-import mlrun.api.utils.helpers
+import mlrun.common.types
 
 
 class ObjectMetadata(BaseModel):
@@ -69,12 +69,12 @@ class ObjectRecord(BaseModel):
         orm_mode = True
 
 
-class ObjectKind(mlrun.api.utils.helpers.StrEnum):
+class ObjectKind(mlrun.common.types.StrEnum):
     project = "project"
     feature_set = "FeatureSet"
     background_task = "BackgroundTask"
     feature_vector = "FeatureVector"
     model_endpoint = "model-endpoint"
-    marketplace_source = "MarketplaceSource"
-    marketplace_item = "MarketplaceItem"
-    marketplace_catalog = "MarketplaceCatalog"
+    hub_source = "HubSource"
+    hub_item = "HubItem"
+    hub_catalog = "HubCatalog"

mlrun/{api → common}/schemas/pipeline.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,10 +16,10 @@ import typing
 
 import pydantic
 
-import mlrun.api.utils.helpers
+import mlrun.common.types
 
 
-class PipelinesFormat(mlrun.api.utils.helpers.StrEnum):
+class PipelinesFormat(mlrun.common.types.StrEnum):
     full = "full"
     metadata_only = "metadata_only"
     summary = "summary"

mlrun/{api → common}/schemas/project.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,12 +17,12 @@ import typing
 
 import pydantic
 
-import mlrun.api.utils.helpers
+import mlrun.common.types
 
 from .object import ObjectKind, ObjectStatus
 
 
-class ProjectsFormat(mlrun.api.utils.helpers.StrEnum):
+class ProjectsFormat(mlrun.common.types.StrEnum):
     full = "full"
     name_only = "name_only"
     # minimal format removes large fields from the response (e.g. functions, workflows, artifacts)
@@ -42,13 +42,13 @@ class ProjectMetadata(pydantic.BaseModel):
         extra = pydantic.Extra.allow
 
 
-class ProjectDesiredState(mlrun.api.utils.helpers.StrEnum):
+class ProjectDesiredState(mlrun.common.types.StrEnum):
     online = "online"
     offline = "offline"
     archived = "archived"
 
 
-class ProjectState(mlrun.api.utils.helpers.StrEnum):
+class ProjectState(mlrun.common.types.StrEnum):
     unknown = "unknown"
     creating = "creating"
     deleting = "deleting"
@@ -83,6 +83,7 @@ class ProjectSpec(pydantic.BaseModel):
     subpath: typing.Optional[str] = None
     origin_url: typing.Optional[str] = None
     desired_state: typing.Optional[ProjectDesiredState] = ProjectDesiredState.online
+    custom_packagers: typing.Optional[typing.List[typing.Tuple[str, bool]]] = None
 
     class Config:
         extra = pydantic.Extra.allow

mlrun/common/schemas/regex.py

@@ -0,0 +1,24 @@
+# Copyright 2018 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import mlrun.common.types
+
+
+class RegexMatchModes(mlrun.common.types.StrEnum):
+    """Regex match modes"""
+
+    # all regexes must match
+    all = "all"
+    # any of the regexes must match
+    any = "any"

mlrun/common/schemas/runs.py

@@ -0,0 +1,30 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+# TODO: When we remove support for python 3.7, we can use Literal from the typing package.
+#       Remove the following try/except block with import from typing_extensions.
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import pydantic
+
+
+class RunIdentifier(pydantic.BaseModel):
+    kind: Literal["run"] = "run"
+    uid: typing.Optional[str]
+    iter: typing.Optional[int]

mlrun/{api → common}/schemas/runtime_resource.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,10 +16,10 @@ import typing
 
 import pydantic
 
-import mlrun.api.utils.helpers
+import mlrun.common.types
 
 
-class ListRuntimeResourcesGroupByField(mlrun.api.utils.helpers.StrEnum):
+class ListRuntimeResourcesGroupByField(mlrun.common.types.StrEnum):
     job = "job"
     project = "project"
 

mlrun/{api → common}/schemas/schedule.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,11 +15,18 @@
 from datetime import datetime
 from typing import Any, List, Optional, Union
 
+# TODO: When we remove support for python 3.7, we can use Literal from the typing package.
+#       Remove the following try/except block with import from typing_extensions.
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
 from pydantic import BaseModel
 
-import mlrun.api.utils.helpers
-from mlrun.api.schemas.auth import Credentials
-from mlrun.api.schemas.object import LabelRecord
+import mlrun.common.types
+from mlrun.common.schemas.auth import Credentials
+from mlrun.common.schemas.object import LabelRecord
 
 
 class ScheduleCronTrigger(BaseModel):
@@ -36,8 +43,8 @@ class ScheduleCronTrigger(BaseModel):
     hour: Optional[Union[int, str]]
     minute: Optional[Union[int, str]]
     second: Optional[Union[int, str]]
-    start_date: Optional[Union[datetime, str]]
-    end_date: Optional[Union[datetime, str]]
+    start_date: Union[datetime, str] = None
+    end_date: Union[datetime, str] = None
 
     # APScheduler also supports datetime.tzinfo type, but Pydantic doesn't - so we don't
     timezone: Optional[str]
@@ -78,7 +85,7 @@ class ScheduleCronTrigger(BaseModel):
         return f"{self.minute} {self.hour} {self.day} {self.month} {self.day_of_week}"
 
 
-class ScheduleKinds(mlrun.api.utils.helpers.StrEnum):
+class ScheduleKinds(mlrun.common.types.StrEnum):
     job = "job"
     pipeline = "pipeline"
 
@@ -136,3 +143,8 @@ class ScheduleOutput(ScheduleRecord):
 
 class SchedulesOutput(BaseModel):
     schedules: List[ScheduleOutput]
+
+
+class ScheduleIdentifier(BaseModel):
+    kind: Literal["schedule"] = "schedule"
+    name: str

mlrun/{api → common}/schemas/secret.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,10 +16,10 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
-import mlrun.api.utils.helpers
+import mlrun.common.types
 
 
-class SecretProviderName(mlrun.api.utils.helpers.StrEnum):
+class SecretProviderName(mlrun.common.types.StrEnum):
     """Enum containing names of valid providers for secrets."""
 
     vault = "vault"

mlrun/{api → common}/schemas/tag.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -29,4 +29,4 @@ class TagObjects(pydantic.BaseModel):
 
     kind: str
     # TODO: Add more types to the list for new supported tagged objects
-    identifiers: typing.List[typing.Union[ArtifactIdentifier]]
+    identifiers: typing.List[ArtifactIdentifier]

mlrun/common/types.py

@@ -0,0 +1,25 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import enum
+
+
+# TODO: From python 3.11 StrEnum is built-in and this will not be needed
+class StrEnum(str, enum.Enum):
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value