mlrun 1.6.0rc35__py3-none-any.whl → 1.7.0rc2__py3-none-any.whl

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -15,8 +15,7 @@
 
 import enum
 import json
-import typing
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel, Field, validator
 from pydantic.main import Extra
@@ -48,7 +47,7 @@ class ModelEndpointMetadata(BaseModel):
         extra = Extra.allow
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
         """Create a `ModelEndpointMetadata` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -71,8 +70,8 @@ class ModelEndpointSpec(ObjectSpec):
     model: Optional[str] = ""  # <model_name>:<version>
     model_class: Optional[str] = ""
     model_uri: Optional[str] = ""
-    feature_names: Optional[List[str]] = []
-    label_names: Optional[List[str]] = []
+    feature_names: Optional[list[str]] = []
+    label_names: Optional[list[str]] = []
     stream_path: Optional[str] = ""
     algorithm: Optional[str] = ""
     monitor_configuration: Optional[dict] = {}
@@ -80,7 +79,7 @@ class ModelEndpointSpec(ObjectSpec):
     monitoring_mode: Optional[ModelMonitoringMode] = ModelMonitoringMode.disabled.value
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
         """Create a `ModelEndpointSpec` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -123,8 +122,8 @@ class ModelEndpointSpec(ObjectSpec):
 
 
 class Histogram(BaseModel):
-    buckets: List[float]
-    counts: List[int]
+    buckets: list[float]
+    counts: list[int]
 
 
 class FeatureValues(BaseModel):
@@ -175,15 +174,15 @@ class ModelEndpointStatus(ObjectStatus):
     error_count: Optional[int] = 0
     drift_status: Optional[str] = ""
     drift_measures: Optional[dict] = {}
-    metrics: Optional[Dict[str, Dict[str, Any]]] = {
+    metrics: Optional[dict[str, dict[str, Any]]] = {
         EventKeyMetrics.GENERIC: {
             EventLiveStats.LATENCY_AVG_1H: 0,
             EventLiveStats.PREDICTIONS_PER_SECOND: 0,
         }
     }
-    features: Optional[List[Features]] = []
-    children: Optional[List[str]] = []
-    children_uids: Optional[List[str]] = []
+    features: Optional[list[Features]] = []
+    children: Optional[list[str]] = []
+    children_uids: Optional[list[str]] = []
     endpoint_type: Optional[EndpointType] = EndpointType.NODE_EP
     monitoring_feature_set_uri: Optional[str] = ""
     state: Optional[str] = ""
@@ -192,7 +191,7 @@ class ModelEndpointStatus(ObjectStatus):
         extra = Extra.allow
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: typing.List = None):
+    def from_flat_dict(cls, endpoint_dict: dict, json_parse_values: list = None):
         """Create a `ModelEndpointStatus` object from an endpoint dictionary
 
         :param endpoint_dict:     Model endpoint dictionary.
@@ -290,13 +289,13 @@ class ModelEndpoint(BaseModel):
 
 
 class ModelEndpointList(BaseModel):
-    endpoints: List[ModelEndpoint] = []
+    endpoints: list[ModelEndpoint] = []
 
 
 def _mapping_attributes(
     base_model: BaseModel,
     flattened_dictionary: dict,
-    json_parse_values: typing.List = None,
+    json_parse_values: list = None,
 ):
     """Generate a `BaseModel` object with the provided dictionary attributes.
 

mlrun/common/schemas/notification.py

@@ -54,14 +54,14 @@ class Notification(pydantic.BaseModel):
     name: str
     message: str
     severity: NotificationSeverity
-    when: typing.List[str]
+    when: list[str]
     condition: str
-    params: typing.Dict[str, typing.Any] = None
+    params: dict[str, typing.Any] = None
     status: NotificationStatus = None
     sent_time: typing.Union[str, datetime.datetime] = None
-    secret_params: typing.Optional[typing.Dict[str, typing.Any]] = None
+    secret_params: typing.Optional[dict[str, typing.Any]] = None
     reason: typing.Optional[str] = None
 
 
 class SetNotificationRequest(pydantic.BaseModel):
-    notifications: typing.List[Notification] = None
+    notifications: list[Notification] = None

mlrun/common/schemas/object.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
 from pydantic import BaseModel, Extra
 
@@ -60,7 +60,7 @@ class ObjectRecord(BaseModel):
     project: str
     uid: str
     updated: Optional[datetime] = None
-    labels: List[LabelRecord]
+    labels: list[LabelRecord]
     # state is extracted from the full status dict to enable queries
     state: Optional[str] = None
     full_object: Optional[dict] = None

mlrun/common/schemas/pipeline.py

@@ -34,6 +34,6 @@ class PipelinesPagination(str):
 
 class PipelinesOutput(pydantic.BaseModel):
     # use the format query param to control what is returned
-    runs: typing.List[typing.Union[dict, str]]
+    runs: list[typing.Union[dict, str]]
     total_size: int
     next_page_token: typing.Optional[str]

mlrun/common/schemas/project.py

@@ -83,7 +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
+    custom_packagers: typing.Optional[list[tuple[str, bool]]] = None
     default_image: typing.Optional[str] = None
 
     class Config:
@@ -127,8 +127,8 @@ class ProjectsOutput(pydantic.BaseModel):
     # union by the definition order. Therefore we can't currently add generic dict for all leader formats, but we need
     # to add a specific classes for them. it's frustrating but couldn't find other workaround, see:
     # https://github.com/samuelcolvin/pydantic/issues/1423, https://github.com/samuelcolvin/pydantic/issues/619
-    projects: typing.List[typing.Union[Project, str, ProjectSummary, IguazioProject]]
+    projects: list[typing.Union[Project, str, ProjectSummary, IguazioProject]]
 
 
 class ProjectSummariesOutput(pydantic.BaseModel):
-    project_summaries: typing.List[ProjectSummary]
+    project_summaries: list[ProjectSummary]

mlrun/common/schemas/runtime_resource.py

@@ -26,15 +26,15 @@ class ListRuntimeResourcesGroupByField(mlrun.common.types.StrEnum):
 
 class RuntimeResource(pydantic.BaseModel):
     name: str
-    labels: typing.Dict[str, str] = {}
-    status: typing.Optional[typing.Dict]
+    labels: dict[str, str] = {}
+    status: typing.Optional[dict]
 
 
 class RuntimeResources(pydantic.BaseModel):
-    crd_resources: typing.List[RuntimeResource] = []
-    pod_resources: typing.List[RuntimeResource] = []
+    crd_resources: list[RuntimeResource] = []
+    pod_resources: list[RuntimeResource] = []
     # only for dask runtime
-    service_resources: typing.Optional[typing.List[RuntimeResource]] = None
+    service_resources: typing.Optional[list[RuntimeResource]] = None
 
     class Config:
         extra = pydantic.Extra.allow
@@ -45,14 +45,10 @@ class KindRuntimeResources(pydantic.BaseModel):
     resources: RuntimeResources
 
 
-RuntimeResourcesOutput = typing.List[KindRuntimeResources]
+RuntimeResourcesOutput = list[KindRuntimeResources]
 
 
 # project name -> job uid -> runtime resources
-GroupedByJobRuntimeResourcesOutput = typing.Dict[
-    str, typing.Dict[str, RuntimeResources]
-]
+GroupedByJobRuntimeResourcesOutput = dict[str, dict[str, RuntimeResources]]
 # project name -> kind -> runtime resources
-GroupedByProjectRuntimeResourcesOutput = typing.Dict[
-    str, typing.Dict[str, RuntimeResources]
-]
+GroupedByProjectRuntimeResourcesOutput = dict[str, dict[str, RuntimeResources]]

mlrun/common/schemas/schedule.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 from datetime import datetime
-from typing import Any, List, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -119,7 +119,7 @@ class ScheduleRecord(ScheduleInput):
     project: str
     last_run_uri: Optional[str]
     state: Optional[str]
-    labels: Optional[List[LabelRecord]]
+    labels: Optional[list[LabelRecord]]
     next_run_time: Optional[datetime]
 
     class Config:
@@ -135,7 +135,7 @@ class ScheduleOutput(ScheduleRecord):
 
 
 class SchedulesOutput(BaseModel):
-    schedules: List[ScheduleOutput]
+    schedules: list[ScheduleOutput]
 
 
 class ScheduleIdentifier(BaseModel):

mlrun/common/schemas/tag.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-import typing
 
 import pydantic
 
@@ -29,4 +28,4 @@ class TagObjects(pydantic.BaseModel):
 
     kind: str
     # TODO: Add more types to the list for new supported tagged objects
-    identifiers: typing.List[ArtifactIdentifier]
+    identifiers: list[ArtifactIdentifier]

mlrun/common/schemas/workflow.py

@@ -36,12 +36,12 @@ class WorkflowSpec(pydantic.BaseModel):
 
 class WorkflowRequest(pydantic.BaseModel):
     spec: typing.Optional[WorkflowSpec] = None
-    arguments: typing.Optional[typing.Dict] = None
+    arguments: typing.Optional[dict] = None
     artifact_path: typing.Optional[str] = None
     source: typing.Optional[str] = None
     run_name: typing.Optional[str] = None
     namespace: typing.Optional[str] = None
-    notifications: typing.Optional[typing.List[Notification]] = None
+    notifications: typing.Optional[list[Notification]] = None
 
 
 class WorkflowResponse(pydantic.BaseModel):

mlrun/config.py

@@ -17,7 +17,7 @@ Configuration system.
 Configuration can be in either a configuration file specified by
 MLRUN_CONFIG_FILE environment variable or by environment variables.
 
-Environment variables are in the format "MLRUN_httpdb__port=8080". This will be
+Environment variables are in the format "MLRUN_HTTPDB__PORT=8080". This will be
 mapped to config.httpdb.port. Values should be in JSON format.
 """
 
@@ -306,7 +306,11 @@ default_config = {
                 # default is 16MB, max 1G, for more info https://dev.mysql.com/doc/refman/8.0/en/packet-too-large.html
                 "max_allowed_packet": 64000000,  # 64MB
             },
-            # None will set this to be equal to the httpdb.max_workers
+            # tests connections for liveness upon each checkout
+            "connections_pool_pre_ping": True,
+            # this setting causes the pool to recycle connections after the given number of seconds has passed
+            "connections_pool_recycle": 60 * 60,
+            # None defaults to httpdb.max_workers
             "connections_pool_size": None,
             "connections_pool_max_overflow": None,
             # below is a db-specific configuration
@@ -344,7 +348,7 @@ default_config = {
             #  ---------------------------------------------------------------------
             # Note: adding a mode requires special handling on
             # - mlrun.runtimes.constants.NuclioIngressAddTemplatedIngressModes
-            # - mlrun.runtimes.function.enrich_function_with_ingress
+            # - mlrun.runtimes.nuclio.function.enrich_function_with_ingress
             "add_templated_ingress_host_mode": "never",
             "explicit_ack": "enabled",
         },
@@ -1122,7 +1126,7 @@ class Config:
             ver in mlrun.mlconf.ce.mode for ver in ["lite", "full"]
         )
 
-    def get_s3_storage_options(self) -> typing.Dict[str, typing.Any]:
+    def get_s3_storage_options(self) -> dict[str, typing.Any]:
         """
         Generate storage options dictionary as required for handling S3 path in fsspec. The model monitoring stream
         graph uses this method for generating the storage options for S3 parquet target path.

mlrun/data_types/to_pandas.py

@@ -94,9 +94,7 @@ def toPandas(spark_df):
                 )
 
                 # Rename columns to avoid duplicated column names.
-                tmp_column_names = [
-                    "col_{}".format(i) for i in range(len(spark_df.columns))
-                ]
+                tmp_column_names = [f"col_{i}" for i in range(len(spark_df.columns))]
                 self_destruct = spark_df.sql_ctx._conf.arrowPySparkSelfDestructEnabled()
                 batches = spark_df.toDF(*tmp_column_names)._collect_as_arrow(
                     split_batches=self_destruct

mlrun/datastore/base.py

@@ -654,34 +654,6 @@ def http_get(url, headers=None, auth=None):
     return response.content
 
 
-def http_head(url, headers=None, auth=None):
-    try:
-        response = requests.head(url, headers=headers, auth=auth, verify=verify_ssl)
-    except OSError as exc:
-        raise OSError(f"error: cannot connect to {url}: {err_to_str(exc)}")
-
-    mlrun.errors.raise_for_status(response)
-
-    return response.headers
-
-
-def http_put(url, data, headers=None, auth=None, session=None):
-    try:
-        put_api = session.put if session else requests.put
-        response = put_api(
-            url, data=data, headers=headers, auth=auth, verify=verify_ssl
-        )
-    except OSError as exc:
-        raise OSError(f"error: cannot connect to {url}: {err_to_str(exc)}") from exc
-
-    mlrun.errors.raise_for_status(response)
-
-
-def http_upload(url, file_path, headers=None, auth=None):
-    with open(file_path, "rb") as data:
-        http_put(url, data, headers, auth)
-
-
 class HttpStore(DataStore):
     def __init__(self, parent, schema, name, endpoint="", secrets: dict = None):
         super().__init__(parent, name, schema, endpoint, secrets)

mlrun/datastore/datastore_profile.py

@@ -30,7 +30,7 @@ from ..secrets import get_secret_or_env
 class DatastoreProfile(pydantic.BaseModel):
     type: str
     name: str
-    _private_attributes: typing.List = ()
+    _private_attributes: list = ()
 
     class Config:
         extra = pydantic.Extra.forbid
@@ -81,8 +81,8 @@ class DatastoreProfileKafkaTarget(DatastoreProfile):
     _private_attributes = "kwargs_private"
     bootstrap_servers: str
     topic: str
-    kwargs_public: typing.Optional[typing.Dict]
-    kwargs_private: typing.Optional[typing.Dict]
+    kwargs_public: typing.Optional[dict]
+    kwargs_private: typing.Optional[dict]
 
     def attributes(self):
         attributes = {"bootstrap_servers": self.bootstrap_servers}
@@ -96,15 +96,15 @@ class DatastoreProfileKafkaTarget(DatastoreProfile):
 class DatastoreProfileKafkaSource(DatastoreProfile):
     type: str = pydantic.Field("kafka_source")
     _private_attributes = ("kwargs_private", "sasl_user", "sasl_pass")
-    brokers: typing.Union[str, typing.List[str]]
-    topics: typing.Union[str, typing.List[str]]
+    brokers: typing.Union[str, list[str]]
+    topics: typing.Union[str, list[str]]
     group: typing.Optional[str] = "serving"
     initial_offset: typing.Optional[str] = "earliest"
-    partitions: typing.Optional[typing.Union[str, typing.List[str]]]
+    partitions: typing.Optional[typing.Union[str, list[str]]]
     sasl_user: typing.Optional[str]
     sasl_pass: typing.Optional[str]
-    kwargs_public: typing.Optional[typing.Dict]
-    kwargs_private: typing.Optional[typing.Dict]
+    kwargs_public: typing.Optional[dict]
+    kwargs_private: typing.Optional[dict]
 
     def attributes(self):
         attributes = {}
@@ -227,7 +227,7 @@ class DatastoreProfileGCS(DatastoreProfile):
     type: str = pydantic.Field("gcs")
     _private_attributes = ("gcp_credentials",)
     credentials_path: typing.Optional[str] = None  # path to file.
-    gcp_credentials: typing.Optional[typing.Union[str, typing.Dict]] = None
+    gcp_credentials: typing.Optional[typing.Union[str, dict]] = None
 
     @pydantic.validator("gcp_credentials", pre=True, always=True)
     def convert_dict_to_json(cls, v):

mlrun/datastore/filestore.py

@@ -105,4 +105,3 @@ class FileStore(DataStore):
                 return
             except FileExistsError:
                 time.sleep(0.1)
-                pass

mlrun/datastore/google_cloud_storage.py

@@ -138,7 +138,7 @@ class GoogleCloudStorageStore(DataStore):
             res = {"spark.hadoop.google.cloud.auth.service.account.enable": "true"}
             if isinstance(st["token"], str):
                 # Token is a filename, read json from it
-                with open(st["token"], "r") as file:
+                with open(st["token"]) as file:
                     credentials = json.load(file)
             else:
                 # Token is a dictionary, use it directly

mlrun/datastore/sources.py

@@ -17,7 +17,7 @@ import warnings
 from base64 import b64encode
 from copy import copy
 from datetime import datetime
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import pandas as pd
 import semver
@@ -170,10 +170,10 @@ class CSVSource(BaseSourceDriver):
         self,
         name: str = "",
         path: str = None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         key_field: str = None,
         schedule: str = None,
-        parse_dates: Union[None, int, str, List[int], List[str]] = None,
+        parse_dates: Union[None, int, str, list[int], list[str]] = None,
         **kwargs,
     ):
         super().__init__(name, path, attributes, key_field, schedule=schedule, **kwargs)
@@ -299,7 +299,7 @@ class ParquetSource(BaseSourceDriver):
         self,
         name: str = "",
         path: str = None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         key_field: str = None,
         time_field: str = None,
         schedule: str = None,
@@ -800,7 +800,7 @@ class OnlineSource(BaseSourceDriver):
         self,
         name: str = None,
         path: str = None,
-        attributes: Dict[str, object] = None,
+        attributes: dict[str, object] = None,
         key_field: str = None,
         time_field: str = None,
         workers: int = None,
@@ -848,8 +848,6 @@ class HttpSource(OnlineSource):
 
 
 class StreamSource(OnlineSource):
-    """Sets stream source for the flow. If stream doesn't exist it will create it"""
-
     kind = "v3ioStream"
 
     def __init__(
@@ -863,7 +861,7 @@ class StreamSource(OnlineSource):
         **kwargs,
     ):
         """
-        Sets stream source for the flow. If stream doesn't exist it will create it
+        Sets the stream source for the flow. If the stream doesn't exist it will create it.
 
         :param name: stream name. Default "stream"
         :param group: consumer group. Default "serving"
@@ -915,8 +913,6 @@ class StreamSource(OnlineSource):
 
 
 class KafkaSource(OnlineSource):
-    """Sets kafka source for the flow"""
-
     kind = "kafka"
 
     def __init__(
@@ -1047,7 +1043,7 @@ class SQLSource(BaseSourceDriver):
         db_url: str = None,
         table_name: str = None,
         spark_options: dict = None,
-        parse_dates: List[str] = None,
+        parse_dates: list[str] = None,
         **kwargs,
     ):
         """

mlrun/datastore/spark_utils.py

@@ -12,12 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
 
 import mlrun
 
 
-def spark_session_update_hadoop_options(session, spark_options) -> Dict[str, str]:
+def spark_session_update_hadoop_options(session, spark_options) -> dict[str, str]:
     hadoop_conf = session.sparkContext._jsc.hadoopConfiguration()
     non_hadoop_spark_options = {}
 

mlrun/datastore/targets.py

@@ -19,7 +19,7 @@ import sys
 import time
 from collections import Counter
 from copy import copy
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 from urllib.parse import urlparse
 
 import pandas as pd
@@ -215,9 +215,8 @@ def validate_target_list(targets):
     ]
     if target_types_requiring_name:
         raise mlrun.errors.MLRunInvalidArgumentError(
-            "Only one default name per target type is allowed (please specify name for {0} target)".format(
-                target_types_requiring_name
-            )
+            "Only one default name per target type is allowed (please "
+            f"specify name for {target_types_requiring_name} target)"
         )
 
     target_names_count = Counter(
@@ -232,9 +231,8 @@ def validate_target_list(targets):
 
     if targets_with_same_name:
         raise mlrun.errors.MLRunInvalidArgumentError(
-            "Each target must have a unique name (more than one target with those names found {0})".format(
-                targets_with_same_name
-            )
+            "Each target must have a unique name (more than one target with "
+            f"those names found {targets_with_same_name})"
         )
 
     no_path_target_types_count = Counter(
@@ -252,9 +250,8 @@ def validate_target_list(targets):
     ]
     if target_types_requiring_path:
         raise mlrun.errors.MLRunInvalidArgumentError(
-            "Only one default path per target type is allowed (please specify path for {0} target)".format(
-                target_types_requiring_path
-            )
+            "Only one default path per target type is allowed (please specify "
+            f"path for {target_types_requiring_path} target)"
         )
 
     target_paths_count = Counter(
@@ -269,9 +266,8 @@ def validate_target_list(targets):
 
     if targets_with_same_path:
         raise mlrun.errors.MLRunInvalidArgumentError(
-            "Each target must have a unique path (more than one target with those names found {0})".format(
-                targets_with_same_path
-            )
+            "Each target must have a unique path (more than one target "
+            f"with those names found {targets_with_same_path})"
         )
 
 
@@ -390,17 +386,17 @@ class BaseStoreTarget(DataTargetBase):
         self,
         name: str = "",
         path=None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         after_step=None,
         columns=None,
         partitioned: bool = False,
         key_bucketing_number: Optional[int] = None,
-        partition_cols: Optional[List[str]] = None,
+        partition_cols: Optional[list[str]] = None,
         time_partitioning_granularity: Optional[str] = None,
         max_events: Optional[int] = None,
         flush_after_seconds: Optional[int] = None,
-        storage_options: Dict[str, str] = None,
-        schema: Dict[str, Any] = None,
+        storage_options: dict[str, str] = None,
+        schema: dict[str, Any] = None,
         credentials_prefix=None,
     ):
         super().__init__(
@@ -731,7 +727,7 @@ class BaseStoreTarget(DataTargetBase):
 
 
 class ParquetTarget(BaseStoreTarget):
-    """parquet target storage driver, used to materialize feature set/vector data into parquet files
+    """Parquet target storage driver, used to materialize feature set/vector data into parquet files.
 
     :param name:       optional, target name. By default will be called ParquetTarget
     :param path:       optional, Output path. Can be either a file or directory.
@@ -766,16 +762,16 @@ class ParquetTarget(BaseStoreTarget):
         self,
         name: str = "",
         path=None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         after_step=None,
         columns=None,
         partitioned: bool = None,
         key_bucketing_number: Optional[int] = None,
-        partition_cols: Optional[List[str]] = None,
+        partition_cols: Optional[list[str]] = None,
         time_partitioning_granularity: Optional[str] = None,
         max_events: Optional[int] = 10000,
         flush_after_seconds: Optional[int] = 900,
-        storage_options: Dict[str, str] = None,
+        storage_options: dict[str, str] = None,
     ):
         self.path = path
         if partitioned is None:
@@ -1652,24 +1648,24 @@ class SQLTarget(BaseStoreTarget):
         self,
         name: str = "",
         path=None,
-        attributes: Dict[str, str] = None,
+        attributes: dict[str, str] = None,
         after_step=None,
         partitioned: bool = False,
         key_bucketing_number: Optional[int] = None,
-        partition_cols: Optional[List[str]] = None,
+        partition_cols: Optional[list[str]] = None,
         time_partitioning_granularity: Optional[str] = None,
         max_events: Optional[int] = None,
         flush_after_seconds: Optional[int] = None,
-        storage_options: Dict[str, str] = None,
+        storage_options: dict[str, str] = None,
         db_url: str = None,
         table_name: str = None,
-        schema: Dict[str, Any] = None,
+        schema: dict[str, Any] = None,
         primary_key_column: str = "",
         if_exists: str = "append",
         create_table: bool = False,
         # create_according_to_data: bool = False,
         varchar_len: int = 50,
-        parse_dates: List[str] = None,
+        parse_dates: list[str] = None,
     ):
         """
         Write to SqlDB as output target for a flow.
@@ -1815,7 +1811,7 @@ class SQLTarget(BaseStoreTarget):
 
         db_path, table_name, _, _, _, _ = self._parse_url()
         engine = sqlalchemy.create_engine(db_path)
-        parse_dates: Optional[List[str]] = self.attributes.get("parse_dates")
+        parse_dates: Optional[list[str]] = self.attributes.get("parse_dates")
         with engine.connect() as conn:
             query, parse_dates = _generate_sql_query_with_time_filter(
                 table_name=table_name,
@@ -1915,12 +1911,16 @@ class SQLTarget(BaseStoreTarget):
                 # creat new table with the given name
                 columns = []
                 for col, col_type in self.schema.items():
-                    col_type = TYPE_TO_SQL_TYPE.get(col_type)
-                    if col_type is None:
-                        raise TypeError(f"{col_type} unsupported type")
+                    col_type_sql = TYPE_TO_SQL_TYPE.get(col_type)
+                    if col_type_sql is None:
+                        raise TypeError(
+                            f"'{col_type}' unsupported type for column '{col}'"
+                        )
                     columns.append(
                         sqlalchemy.Column(
-                            col, col_type, primary_key=(col in primary_key_for_check)
+                            col,
+                            col_type_sql,
+                            primary_key=(col in primary_key_for_check),
                         )
                     )