mlrun 1.5.0rc4__py3-none-any.whl → 1.5.0rc6__py3-none-any.whl

mlrun/api/crud/hub.py

@@ -15,6 +15,9 @@
 import json
 from typing import Any, Dict, List, Optional, Tuple
 
+import sqlalchemy.orm
+
+import mlrun.api.utils.singletons.db
 import mlrun.api.utils.singletons.k8s
 import mlrun.common.schemas
 import mlrun.common.schemas.hub
@@ -35,20 +38,6 @@ class Hub(metaclass=mlrun.utils.singleton.Singleton):
         self._internal_project_name = config.hub.k8s_secrets_project_name
         self._catalogs = {}
 
-    @staticmethod
-    def _in_k8s():
-        k8s_helper = mlrun.api.utils.singletons.k8s.get_k8s_helper()
-        return (
-            k8s_helper is not None and k8s_helper.is_running_inside_kubernetes_cluster()
-        )
-
-    @staticmethod
-    def _generate_credentials_secret_key(source, key=""):
-        full_key = source + secret_name_separator + key
-        return Secrets().generate_client_project_secret_key(
-            SecretsClientType.hub, full_key
-        )
-
     def add_source(self, source: mlrun.common.schemas.hub.HubSource):
         source_name = source.metadata.name
         credentials = source.spec.credentials
@@ -74,118 +63,6 @@ class Hub(metaclass=mlrun.utils.singleton.Singleton):
             allow_internal_secrets=True,
         )
 
-    def _store_source_credentials(self, source_name, credentials: dict):
-        if not self._in_k8s():
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "MLRun is not configured with k8s, hub source credentials cannot be stored securely"
-            )
-
-        adjusted_credentials = {
-            self._generate_credentials_secret_key(source_name, key): value
-            for key, value in credentials.items()
-        }
-        Secrets().store_project_secrets(
-            self._internal_project_name,
-            mlrun.common.schemas.SecretsData(
-                provider=mlrun.common.schemas.SecretProviderName.kubernetes,
-                secrets=adjusted_credentials,
-            ),
-            allow_internal_secrets=True,
-        )
-
-    def _get_source_credentials(self, source_name):
-        if not self._in_k8s():
-            return {}
-
-        secret_prefix = self._generate_credentials_secret_key(source_name)
-        secrets = (
-            Secrets()
-            .list_project_secrets(
-                self._internal_project_name,
-                mlrun.common.schemas.SecretProviderName.kubernetes,
-                allow_secrets_from_k8s=True,
-                allow_internal_secrets=True,
-            )
-            .secrets
-        )
-
-        source_secrets = {}
-        for key, value in secrets.items():
-            if key.startswith(secret_prefix):
-                source_secrets[key[len(secret_prefix) :]] = value
-
-        return source_secrets
-
-    @staticmethod
-    def _get_asset_full_path(
-        source: mlrun.common.schemas.hub.HubSource,
-        item: mlrun.common.schemas.hub.HubItem,
-        asset: str,
-    ):
-        """
-        Combining the item path with the asset path.
-
-        :param source:  Hub source object.
-        :param item:    The relevant item to get the asset from.
-        :param asset:   The asset name
-        :return:    Full path to the asset, relative to the item directory.
-        """
-        asset_path = item.spec.assets.get(asset, None)
-        if not asset_path:
-            raise mlrun.errors.MLRunNotFoundError(
-                f"Asset={asset} not found. "
-                f"item={item.metadata.name}, version={item.metadata.version}, tag={item.metadata.tag}"
-            )
-        item_path = item.metadata.get_relative_path()
-        return source.get_full_uri(item_path + asset_path)
-
-    @staticmethod
-    def _transform_catalog_dict_to_schema(
-        source: mlrun.common.schemas.hub.HubSource, catalog_dict: Dict[str, Any]
-    ) -> mlrun.common.schemas.hub.HubCatalog:
-        """
-        Transforms catalog dictionary to HubCatalog schema
-        :param source:          Hub source object.
-        :param catalog_dict:    raw catalog dict, top level keys are item names,
-                                second level keys are version tags ("latest, "1.1.0", ...) and
-                                bottom level keys include spec as a dict and all the rest is considered as metadata.
-        :return: catalog object
-        """
-        catalog = mlrun.common.schemas.hub.HubCatalog(
-            catalog=[], channel=source.spec.channel
-        )
-        # Loop over objects, then over object versions.
-        for object_name, object_dict in catalog_dict.items():
-            for version_tag, version_dict in object_dict.items():
-                object_details_dict = version_dict.copy()
-                spec_dict = object_details_dict.pop("spec", {})
-                assets = object_details_dict.pop("assets", {})
-                # We want to align all item names to be normalized.
-                # This is necessary since the item names are originally collected from the yaml files
-                # which may can contain underscores.
-                object_details_dict.update(
-                    {
-                        "name": mlrun.utils.helpers.normalize_name(
-                            object_name, verbose=False
-                        )
-                    }
-                )
-                metadata = mlrun.common.schemas.hub.HubItemMetadata(
-                    tag=version_tag, **object_details_dict
-                )
-                item_uri = source.get_full_uri(metadata.get_relative_path())
-                spec = mlrun.common.schemas.hub.HubItemSpec(
-                    item_uri=item_uri, assets=assets, **spec_dict
-                )
-                item = mlrun.common.schemas.hub.HubItem(
-                    metadata=metadata,
-                    spec=spec,
-                    status=mlrun.common.schemas.ObjectStatus(),
-                )
-                catalog.catalog.append(item)
-
-        return catalog
-
     def get_source_catalog(
         self,
         source: mlrun.common.schemas.hub.HubSource,
@@ -265,22 +142,6 @@ class Hub(metaclass=mlrun.utils.singleton.Singleton):
             )
         return items[0]
 
-    @staticmethod
-    def _get_catalog_items_filtered_by_name(
-        catalog: List[mlrun.common.schemas.hub.HubItem],
-        item_name: str,
-    ) -> List[mlrun.common.schemas.hub.HubItem]:
-        """
-        Retrieve items from catalog filtered by name
-
-        :param catalog:     list of items
-        :param item_name:   item name to filter by
-
-        :return:   list of item objects from catalog
-        """
-        normalized_name = mlrun.utils.helpers.normalize_name(item_name, verbose=False)
-        return [item for item in catalog if item.metadata.name == normalized_name]
-
     def get_item_object_using_source_credentials(
         self, source: mlrun.common.schemas.hub.HubSource, url
     ):
@@ -323,6 +184,19 @@ class Hub(metaclass=mlrun.utils.singleton.Singleton):
             asset_path,
         )
 
+    def list_hub_sources(
+        self,
+        db_session: sqlalchemy.orm.Session,
+        item_name: Optional[str] = None,
+        tag: Optional[str] = None,
+        version: Optional[str] = None,
+    ) -> List[mlrun.common.schemas.IndexedHubSource]:
+
+        hub_sources = mlrun.api.utils.singletons.db.get_db().list_hub_sources(
+            db_session
+        )
+        return self.filter_hub_sources(hub_sources, item_name, tag, version)
+
     def filter_hub_sources(
         self,
         sources: List[mlrun.common.schemas.IndexedHubSource],
@@ -360,3 +234,145 @@ class Hub(metaclass=mlrun.utils.singleton.Singleton):
                     filtered_sources.append(source)
                     break
         return filtered_sources
+
+    @staticmethod
+    def _in_k8s():
+        k8s_helper = mlrun.api.utils.singletons.k8s.get_k8s_helper()
+        return (
+            k8s_helper is not None and k8s_helper.is_running_inside_kubernetes_cluster()
+        )
+
+    @staticmethod
+    def _generate_credentials_secret_key(source, key=""):
+        full_key = source + secret_name_separator + key
+        return Secrets().generate_client_project_secret_key(
+            SecretsClientType.hub, full_key
+        )
+
+    def _store_source_credentials(self, source_name, credentials: dict):
+        if not self._in_k8s():
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "MLRun is not configured with k8s, hub source credentials cannot be stored securely"
+            )
+
+        adjusted_credentials = {
+            self._generate_credentials_secret_key(source_name, key): value
+            for key, value in credentials.items()
+        }
+        Secrets().store_project_secrets(
+            self._internal_project_name,
+            mlrun.common.schemas.SecretsData(
+                provider=mlrun.common.schemas.SecretProviderName.kubernetes,
+                secrets=adjusted_credentials,
+            ),
+            allow_internal_secrets=True,
+        )
+
+    def _get_source_credentials(self, source_name):
+        if not self._in_k8s():
+            return {}
+
+        secret_prefix = self._generate_credentials_secret_key(source_name)
+        secrets = (
+            Secrets()
+            .list_project_secrets(
+                self._internal_project_name,
+                mlrun.common.schemas.SecretProviderName.kubernetes,
+                allow_secrets_from_k8s=True,
+                allow_internal_secrets=True,
+            )
+            .secrets
+        )
+
+        source_secrets = {}
+        for key, value in secrets.items():
+            if key.startswith(secret_prefix):
+                source_secrets[key[len(secret_prefix) :]] = value
+
+        return source_secrets
+
+    @staticmethod
+    def _get_asset_full_path(
+        source: mlrun.common.schemas.hub.HubSource,
+        item: mlrun.common.schemas.hub.HubItem,
+        asset: str,
+    ):
+        """
+        Combining the item path with the asset path.
+
+        :param source:  Hub source object.
+        :param item:    The relevant item to get the asset from.
+        :param asset:   The asset name
+        :return:    Full path to the asset, relative to the item directory.
+        """
+        asset_path = item.spec.assets.get(asset, None)
+        if not asset_path:
+            raise mlrun.errors.MLRunNotFoundError(
+                f"Asset={asset} not found. "
+                f"item={item.metadata.name}, version={item.metadata.version}, tag={item.metadata.tag}"
+            )
+        item_path = item.metadata.get_relative_path()
+        return source.get_full_uri(item_path + asset_path)
+
+    @staticmethod
+    def _transform_catalog_dict_to_schema(
+        source: mlrun.common.schemas.hub.HubSource, catalog_dict: Dict[str, Any]
+    ) -> mlrun.common.schemas.hub.HubCatalog:
+        """
+        Transforms catalog dictionary to HubCatalog schema
+        :param source:          Hub source object.
+        :param catalog_dict:    raw catalog dict, top level keys are item names,
+                                second level keys are version tags ("latest, "1.1.0", ...) and
+                                bottom level keys include spec as a dict and all the rest is considered as metadata.
+        :return: catalog object
+        """
+        catalog = mlrun.common.schemas.hub.HubCatalog(
+            catalog=[], channel=source.spec.channel
+        )
+        # Loop over objects, then over object versions.
+        for object_name, object_dict in catalog_dict.items():
+            for version_tag, version_dict in object_dict.items():
+                object_details_dict = version_dict.copy()
+                spec_dict = object_details_dict.pop("spec", {})
+                assets = object_details_dict.pop("assets", {})
+                # We want to align all item names to be normalized.
+                # This is necessary since the item names are originally collected from the yaml files
+                # which may can contain underscores.
+                object_details_dict.update(
+                    {
+                        "name": mlrun.utils.helpers.normalize_name(
+                            object_name, verbose=False
+                        )
+                    }
+                )
+                metadata = mlrun.common.schemas.hub.HubItemMetadata(
+                    tag=version_tag, **object_details_dict
+                )
+                item_uri = source.get_full_uri(metadata.get_relative_path())
+                spec = mlrun.common.schemas.hub.HubItemSpec(
+                    item_uri=item_uri, assets=assets, **spec_dict
+                )
+                item = mlrun.common.schemas.hub.HubItem(
+                    metadata=metadata,
+                    spec=spec,
+                    status=mlrun.common.schemas.ObjectStatus(),
+                )
+                catalog.catalog.append(item)
+
+        return catalog
+
+    @staticmethod
+    def _get_catalog_items_filtered_by_name(
+        catalog: List[mlrun.common.schemas.hub.HubItem],
+        item_name: str,
+    ) -> List[mlrun.common.schemas.hub.HubItem]:
+        """
+        Retrieve items from catalog filtered by name
+
+        :param catalog:     list of items
+        :param item_name:   item name to filter by
+
+        :return:   list of item objects from catalog
+        """
+        normalized_name = mlrun.utils.helpers.normalize_name(item_name, verbose=False)
+        return [item for item in catalog if item.metadata.name == normalized_name]

mlrun/api/crud/model_monitoring/deployment.py

@@ -216,6 +216,7 @@ class MonitoringDeployment:
             fn = self._get_model_monitoring_batch_function(
                 project=project,
                 model_monitoring_access_key=model_monitoring_access_key,
+                db_session=db_session,
                 auth_info=auth_info,
                 tracking_policy=tracking_policy,
             )
@@ -319,6 +320,7 @@ class MonitoringDeployment:
         self,
         project: str,
         model_monitoring_access_key: str,
+        db_session: sqlalchemy.orm.Session,
         auth_info: mlrun.common.schemas.AuthInfo,
         tracking_policy: mlrun.model_monitoring.tracking_policy.TrackingPolicy,
     ):
@@ -345,6 +347,7 @@ class MonitoringDeployment:
             image=tracking_policy.default_batch_image,
             handler="handler",
         )
+        function.set_db_connection(mlrun.api.api.utils.get_run_db_instance(db_session))
 
         # Set the project to the job function
         function.metadata.project = project

mlrun/api/crud/model_monitoring/model_endpoints.py

@@ -93,7 +93,7 @@ class ModelEndpoints:
             logger.info(
                 "Getting model object, inferring column names and collecting feature stats"
             )
-            run_db = mlrun.get_run_db()
+            run_db = mlrun.api.api.utils.get_run_db_instance(db_session)
             model_obj: mlrun.artifacts.ModelArtifact = (
                 mlrun.datastore.store_resources.get_store_resource(
                     model_endpoint.spec.model_uri, db=run_db

mlrun/api/crud/pipelines.py

@@ -95,7 +95,7 @@ class Pipelines(
             runs = [run.to_dict() for run in response.runs or []]
             total_size = response.total_size
             next_page_token = response.next_page_token
-        runs = self._format_runs(runs, format_)
+        runs = self._format_runs(db_session, runs, format_)
 
         return total_size, next_page_token, runs
 
@@ -131,6 +131,7 @@ class Pipelines(
 
     def get_pipeline(
         self,
+        db_session: sqlalchemy.orm.Session,
         run_id: str,
         project: typing.Optional[str] = None,
         namespace: typing.Optional[str] = None,
@@ -148,7 +149,9 @@ class Pipelines(
                         raise mlrun.errors.MLRunNotFoundError(
                             f"Pipeline run with id {run_id} is not of project {project}"
                         )
-                run = self._format_run(run, format_, api_run_detail.to_dict())
+                run = self._format_run(
+                    db_session, run, format_, api_run_detail.to_dict()
+                )
         except kfp_server_api.ApiException as exc:
             mlrun.errors.raise_for_status_code(int(exc.status), err_to_str(exc))
         except mlrun.errors.MLRunHTTPStatusError:
@@ -225,16 +228,18 @@ class Pipelines(
 
     def _format_runs(
         self,
+        db_session: sqlalchemy.orm.Session,
         runs: typing.List[dict],
         format_: mlrun.common.schemas.PipelinesFormat = mlrun.common.schemas.PipelinesFormat.metadata_only,
     ) -> typing.List[dict]:
         formatted_runs = []
         for run in runs:
-            formatted_runs.append(self._format_run(run, format_))
+            formatted_runs.append(self._format_run(db_session, run, format_))
         return formatted_runs
 
     def _format_run(
         self,
+        db_session: sqlalchemy.orm.Session,
         run: dict,
         format_: mlrun.common.schemas.PipelinesFormat = mlrun.common.schemas.PipelinesFormat.metadata_only,
         api_run_detail: typing.Optional[dict] = None,
@@ -252,8 +257,9 @@ class Pipelines(
                 raise mlrun.errors.MLRunRuntimeError(
                     "The full kfp api_run_detail object is needed to generate the summary format"
                 )
+            run_db = mlrun.api.api.utils.get_run_db_instance(db_session)
             return mlrun.kfpops.format_summary_from_kfp_run(
-                api_run_detail, run["project"]
+                api_run_detail, run["project"], run_db=run_db
             )
         else:
             raise NotImplementedError(

mlrun/api/crud/workflows.py

@@ -18,14 +18,15 @@ from typing import Dict
 from sqlalchemy.orm import Session
 
 import mlrun.common.schemas
-import mlrun.db
 import mlrun.utils.singleton
 from mlrun.api.api.utils import (
     apply_enrichment_and_validation_on_function,
+    get_run_db_instance,
     get_scheduler,
 )
 from mlrun.config import config
 from mlrun.model import Credentials, RunMetadata, RunObject, RunSpec
+from mlrun.utils import fill_project_path_template
 
 
 class WorkflowRunners(
@@ -35,6 +36,7 @@ class WorkflowRunners(
     def create_runner(
         run_name: str,
         project: str,
+        db_session: Session,
         auth_info: mlrun.common.schemas.AuthInfo,
         image: str,
     ) -> mlrun.run.KubejobRuntime:
@@ -58,6 +60,8 @@ class WorkflowRunners(
             image=image,
         )
 
+        runner.set_db_connection(get_run_db_instance(db_session))
+
         # Enrichment and validation requires access key
         runner.metadata.credentials.access_key = Credentials.generate_access_key
 
@@ -158,9 +162,12 @@ class WorkflowRunners(
                 ),
                 handler="mlrun.projects.load_and_run",
                 scrape_metrics=config.scrape_metrics,
-                output_path=(
-                    workflow_request.artifact_path or config.artifact_path
-                ).replace("{{run.uid}}", meta_uid),
+                output_path=fill_project_path_template(
+                    (workflow_request.artifact_path or config.artifact_path).replace(
+                        "{{run.uid}}", meta_uid
+                    ),
+                    project.metadata.name,
+                ),
             ),
             metadata=RunMetadata(
                 uid=meta_uid, name=workflow_spec.name, project=project.metadata.name

mlrun/api/db/session.py

@@ -25,10 +25,15 @@ def close_session(db_session):
     db_session.close()
 
 
-def run_function_with_new_db_session(func):
+def run_function_with_new_db_session(func, *args, **kwargs):
+    """
+    Run a function with a new db session, useful for cuncurrent requests where we can't share a single session.
+    However, any changes made by the new session will not be visible to old sessions until the old sessions commit
+    due to isolation level.
+    """
     session = create_session()
     try:
-        result = func(session)
+        result = func(session, *args, **kwargs)
         return result
     finally:
         close_session(session)

mlrun/api/db/sqldb/db.py

@@ -110,7 +110,6 @@ def retry_on_conflict(function):
             try:
                 return function(*args, **kwargs)
             except Exception as exc:
-
                 if mlrun.utils.helpers.are_strings_in_exception_chain_messages(
                     exc, conflict_messages
                 ):
@@ -140,11 +139,8 @@ def retry_on_conflict(function):
 
 
 class SQLDB(DBInterface):
-    def __init__(self, dsn):
+    def __init__(self, dsn=""):
         self.dsn = dsn
-        self._cache = {
-            "project_resources_counters": {"value": None, "ttl": datetime.min}
-        }
         self._name_with_iter_regex = re.compile("^[0-9]+-.+$")
 
     def initialize(self, session):
@@ -1102,7 +1098,6 @@ class SQLDB(DBInterface):
             if not tag:
                 function_tags = self._list_function_tags(session, project, function.id)
                 if len(function_tags) == 0:
-
                     # function status should be added only to tagged functions
                     function_dict["status"] = None
 
@@ -1244,7 +1239,6 @@ class SQLDB(DBInterface):
         labels: Dict = None,
         next_run_time: datetime = None,
     ) -> mlrun.common.schemas.ScheduleRecord:
-
         schedule_record = self._create_schedule_db_record(
             project=project,
             name=name,
@@ -2216,7 +2210,6 @@ class SQLDB(DBInterface):
         partition_order: mlrun.common.schemas.OrderType,
         max_partitions: int = 0,
     ):
-
         partition_field = partition_by.to_partition_by_db_field(cls)
         sort_by_field = partition_sort_by.to_db_field(cls)
 
@@ -2484,7 +2477,6 @@ class SQLDB(DBInterface):
             if uid == existing_feature_set.uid or always_overwrite:
                 db_feature_set = existing_feature_set
             else:
-
                 # In case an object with the given tag (or 'latest' which is the default) and name, but different uid
                 # was found - Check If an object with the same computed uid but different tag already exists
                 # and re-tag it.
@@ -2814,7 +2806,6 @@ class SQLDB(DBInterface):
             if uid == existing_feature_vector.uid or always_overwrite:
                 db_feature_vector = existing_feature_vector
             else:
-
                 # In case an object with the given tag (or 'latest' which is the default) and name, but different uid
                 # was found - Check If an object with the same computed uid but different tag already exists
                 # and re-tag it.
@@ -3862,7 +3853,6 @@ class SQLDB(DBInterface):
         run_uid: str,
         project: str = "",
     ) -> typing.List[mlrun.model.Notification]:
-
         # iteration is 0, as we don't support multiple notifications per hyper param run, only for the whole run
         run = self._get_run(session, run_uid, project, 0)
         if not run:
@@ -3885,7 +3875,6 @@ class SQLDB(DBInterface):
     ):
         run_id = None
         if run_uid:
-
             # iteration is 0, as we don't support multiple notifications per hyper param run, only for the whole run
             run = self._get_run(session, run_uid, project, 0)
             if not run:
@@ -3947,6 +3936,17 @@ class SQLDB(DBInterface):
             )
         self._commit(session, [run], ignore=True)
 
+    @staticmethod
+    def _transform_datastore_profile_model_to_schema(
+        db_object,
+    ) -> mlrun.common.schemas.DatastoreProfile:
+        return mlrun.common.schemas.DatastoreProfile(
+            name=db_object.name,
+            type=db_object.type,
+            object=db_object.full_object,
+            project=db_object.project,
+        )
+
     def store_datastore_profile(
         self, session, info: mlrun.common.schemas.DatastoreProfile
     ):
@@ -3959,18 +3959,17 @@ class SQLDB(DBInterface):
         info.project = info.project or config.default_project
         profile = self._query(
             session, DatastoreProfile, name=info.name, project=info.project
-        )
-        first = profile.first()
-        if first:
-            first.type = info.type
-            first.body = info.body
+        ).one_or_none()
+        if profile:
+            profile.type = info.type
+            profile.full_object = info.object
             self._commit(session, [profile])
         else:
             profile = DatastoreProfile(
                 name=info.name,
                 type=info.type,
                 project=info.project,
-                body=info.body,
+                full_object=info.object,
             )
             self._upsert(session, [profile])
 
@@ -3990,8 +3989,7 @@ class SQLDB(DBInterface):
         project = project or config.default_project
         res = self._query(session, DatastoreProfile, name=profile, project=project)
         if res.first():
-            r = res.first().to_dict(exclude=["id"])
-            return mlrun.common.schemas.DatastoreProfile(**r)
+            return self._transform_datastore_profile_model_to_schema(res.first())
         else:
             raise mlrun.errors.MLRunNotFoundError(
                 f"Datastore profile '{profile}' not found in project '{project}'"
@@ -4027,7 +4025,7 @@ class SQLDB(DBInterface):
         project = project or config.default_project
         query_results = self._query(session, DatastoreProfile, project=project)
         return [
-            mlrun.common.schemas.DatastoreProfile(**query.to_dict(exclude=["id"]))
+            self._transform_datastore_profile_model_to_schema(query)
             for query in query_results
         ]
 

mlrun/api/db/sqldb/models/models_mysql.py

@@ -532,7 +532,16 @@ with warnings.catch_warnings():
         name = Column(String(255, collation=SQLCollationUtil.collation()))
         project = Column(String(255, collation=SQLCollationUtil.collation()))
         type = Column(String(255, collation=SQLCollationUtil.collation()))
-        body = Column(String(1024, collation=SQLCollationUtil.collation()))
+        _full_object = Column("object", JSON)
+
+        @property
+        def full_object(self):
+            if self._full_object:
+                return json.loads(self._full_object)
+
+        @full_object.setter
+        def full_object(self, value):
+            self._full_object = json.dumps(value, default=str)
 
 
 # Must be after all table definitions

mlrun/api/db/sqldb/models/models_sqlite.py

@@ -488,7 +488,17 @@ with warnings.catch_warnings():
         name = Column(String(255, collation=SQLCollationUtil.collation()))
         type = Column(String(255, collation=SQLCollationUtil.collation()))
         project = Column(String(255, collation=SQLCollationUtil.collation()))
-        body = Column(String(1024, collation=SQLCollationUtil.collation()))
+
+        _full_object = Column("object", JSON)
+
+        @property
+        def full_object(self):
+            if self._full_object:
+                return json.loads(self._full_object)
+
+        @full_object.setter
+        def full_object(self, value):
+            self._full_object = json.dumps(value, default=str)
 
 
 # Must be after all table definitions