[WIP] Staging/dev/profile serialization

dataprofiler/labelers/base_data_labeler.py

@@ -637,7 +637,9 @@ def load_from_library(cls, name: str) -> BaseDataLabeler:
         :return: DataLabeler class
         :rtype: BaseDataLabeler
         """
-        return cls(os.path.join(default_labeler_dir, name))
+        labeler = cls(os.path.join(default_labeler_dir, name))
+        labeler._default_model_loc = name
+        return labeler
 
     @classmethod
     def load_from_disk(cls, dirpath: str, load_options: dict = None) -> BaseDataLabeler:

dataprofiler/labelers/data_labelers.py

@@ -102,7 +102,7 @@ def __new__(  # type: ignore
         trainable: bool = False,
     ) -> BaseDataLabeler:
         """
-        Create structured and unstructred data labeler objects.
+        Create structured and unstructured data labeler objects.
 
         :param dirpath: Path to load data labeler
         :type dirpath: str
@@ -143,6 +143,9 @@ def load_from_library(cls, name: str, trainable: bool = False) -> BaseDataLabele
         """
         if trainable:
             return TrainableDataLabeler.load_from_library(name)
+        for _, labeler_class_obj in cls.labeler_classes.items():
+            if name in labeler_class_obj._default_model_loc:
+                return labeler_class_obj()
         return BaseDataLabeler.load_from_library(name)
 
     @classmethod

dataprofiler/profilers/__init__.py

@@ -1,12 +1,92 @@
 """Package for providing statistics and predictions for a given dataset."""
+from . import json_decoder
 from .base_column_profilers import BaseColumnProfiler
 from .categorical_column_profile import CategoricalColumn
+from .column_profile_compilers import (
+    BaseCompiler,
+    ColumnDataLabelerCompiler,
+    ColumnPrimitiveTypeProfileCompiler,
+    ColumnStatsProfileCompiler,
+)
 from .data_labeler_column_profile import DataLabelerColumn
 from .datetime_column_profile import DateTimeColumn
 from .float_column_profile import FloatColumn
 from .int_column_profile import IntColumn
 from .numerical_column_stats import NumericStatsMixin
 from .order_column_profile import OrderColumn
-from .profile_builder import Profiler, StructuredProfiler, UnstructuredProfiler
+from .profile_builder import (
+    Profiler,
+    StructuredColProfiler,
+    StructuredProfiler,
+    UnstructuredProfiler,
+)
+from .profiler_options import (
+    BaseInspectorOptions,
+    BooleanOption,
+    CategoricalOptions,
+    CorrelationOptions,
+    DataLabelerOptions,
+    DateTimeOptions,
+    FloatOptions,
+    HistogramOption,
+    IntOptions,
+    ModeOption,
+    NumericalOptions,
+    OrderOptions,
+    PrecisionOptions,
+    ProfilerOptions,
+    StructuredOptions,
+    TextOptions,
+    TextProfilerOptions,
+    UnstructuredOptions,
+)
 from .text_column_profile import TextColumn
 from .unstructured_labeler_profile import UnstructuredLabelerProfile
+
+# set here to avoid circular imports
+json_decoder._profiles = {
+    CategoricalColumn.__name__: CategoricalColumn,
+    FloatColumn.__name__: FloatColumn,
+    IntColumn.__name__: IntColumn,
+    DateTimeColumn.__name__: DateTimeColumn,
+    OrderColumn.__name__: OrderColumn,
+    DataLabelerColumn.__name__: DataLabelerColumn,
+    TextColumn.__name__: TextColumn,
+}
+
+
+json_decoder._compilers = {
+    ColumnDataLabelerCompiler.__name__: ColumnDataLabelerCompiler,
+    ColumnPrimitiveTypeProfileCompiler.__name__: ColumnPrimitiveTypeProfileCompiler,
+    ColumnStatsProfileCompiler.__name__: ColumnStatsProfileCompiler,
+}
+
+json_decoder._options = {
+    BooleanOption.__name__: BooleanOption,
+    HistogramOption.__name__: HistogramOption,
+    ModeOption.__name__: ModeOption,
+    BaseInspectorOptions.__name__: BaseInspectorOptions,
+    NumericalOptions.__name__: NumericalOptions,
+    IntOptions.__name__: IntOptions,
+    PrecisionOptions.__name__: PrecisionOptions,
+    FloatOptions.__name__: FloatOptions,
+    TextOptions.__name__: TextOptions,
+    DateTimeOptions.__name__: DateTimeOptions,
+    OrderOptions.__name__: OrderOptions,
+    CategoricalOptions.__name__: CategoricalOptions,
+    CorrelationOptions.__name__: CorrelationOptions,
+    DataLabelerOptions.__name__: DataLabelerOptions,
+    TextProfilerOptions.__name__: TextProfilerOptions,
+    StructuredOptions.__name__: StructuredOptions,
+    UnstructuredOptions.__name__: UnstructuredOptions,
+    ProfilerOptions.__name__: ProfilerOptions,
+}
+
+
+json_decoder._profilers = {
+    StructuredProfiler.__name__: StructuredProfiler,
+}
+
+json_decoder._structured_col_profiler = {
+    StructuredColProfiler.__name__: StructuredColProfiler,
+}

dataprofiler/profilers/base_column_profilers.py

@@ -6,17 +6,18 @@
 import abc
 import warnings
 from collections import defaultdict
-from typing import Any, Callable
+from typing import Any, Callable, Generic, TypeVar
 
 import numpy as np
 import pandas as pd
 
-from dataprofiler.profilers.profiler_options import BaseInspectorOptions
-
 from . import utils
+from .profiler_options import BaseInspectorOptions, BaseOption
+
+BaseColumnProfilerT = TypeVar("BaseColumnProfilerT", bound="BaseColumnProfiler")
 
 
-class BaseColumnProfiler(metaclass=abc.ABCMeta):  # type: ignore
+class BaseColumnProfiler(Generic[BaseColumnProfilerT], metaclass=abc.ABCMeta):
     """Abstract class for profiling a column of data."""
 
     col_type = None
@@ -28,7 +29,7 @@ class BaseColumnProfiler(metaclass=abc.ABCMeta):  # type: ignore
     _SAMPLING_RATIO = 0.20
     _MIN_SAMPLING_COUNT = 500
 
-    def __init__(self, name: str | None) -> None:
+    def __init__(self, name: str | None, options: BaseOption | None = None):
         """
         Initialize base class properties for the subclass.
 
@@ -147,7 +148,7 @@ def _merge_calculations(
                     )
 
     def _add_helper(
-        self, other1: BaseColumnProfiler, other2: BaseColumnProfiler
+        self, other1: BaseColumnProfilerT, other2: BaseColumnProfilerT
     ) -> None:
         """
         Merge the properties of two BaseColumnProfile objects.
@@ -176,7 +177,7 @@ def _add_helper(
 
         self.sample_size = other1.sample_size + other2.sample_size
 
-    def diff(self, other_profile: BaseColumnProfiler, options: dict = None) -> dict:
+    def diff(self, other_profile: BaseColumnProfilerT, options: dict = None) -> dict:
         """
         Find the differences for columns.
 
@@ -247,10 +248,53 @@ def report(self, remove_disabled_flag: bool = False) -> dict:
         """
         raise NotImplementedError()
 
+    @classmethod
+    def load_from_dict(
+        cls: type[BaseColumnProfilerT],
+        data: dict[str, Any],
+        options: dict | None = None,
+    ) -> BaseColumnProfilerT:
+        """
+        Parse attribute from json dictionary into self.
+
+        :param data: dictionary with attributes and values.
+        :type data: dict[string, Any]
+        :param options: options for loading column profiler params from dictionary
+        :type options: Dict | None
+
+        :return: Profiler with attributes populated.
+        :rtype: BaseColumnProfiler
+        """
+        if options is None:
+            options = {}
+
+        class_options = options.get(cls.__name__)
+        profile: BaseColumnProfilerT = cls(data["name"], class_options)
+
+        time_vals = data.pop("times")
+        setattr(profile, "times", defaultdict(float, time_vals))
+
+        for attr, value in data.items():
+            if "__calculations" in attr:
+                for metric, function in value.items():
+                    if not hasattr(profile, function):
+                        raise AttributeError(
+                            f"Object {type(profile)} has no attribute {function}."
+                        )
+                    value[metric] = getattr(profile, function).__func__
+            setattr(profile, attr, value)
+
+        return profile
+
+
+BaseColumnPrimitiveTypeProfilerT = TypeVar(
+    "BaseColumnPrimitiveTypeProfilerT", bound="BaseColumnPrimitiveTypeProfiler"
+)
+
 
 class BaseColumnPrimitiveTypeProfiler(
-    BaseColumnProfiler,
-    metaclass=abc.ABCMeta,  # type: ignore
+    BaseColumnProfiler[BaseColumnPrimitiveTypeProfilerT],
+    metaclass=abc.ABCMeta,
 ):
     """Abstract class for profiling primative data type for col of data."""
 
@@ -275,13 +319,13 @@ def _update_column_base_properties(self, profile: dict) -> None:
         :type profile: base data profile dict
         :return: None
         """
-        self.match_count += profile.pop("match_count")
+        self.match_count += int(profile.pop("match_count"))
         BaseColumnProfiler._update_column_base_properties(self, profile)
 
-    def _add_helper(  # type: ignore[override]
+    def _add_helper(
         self,
-        other1: BaseColumnPrimitiveTypeProfiler,
-        other2: BaseColumnPrimitiveTypeProfiler,
+        other1: BaseColumnPrimitiveTypeProfilerT,
+        other2: BaseColumnPrimitiveTypeProfilerT,
     ) -> None:
         """
         Merge the properties of two objects inputted.
@@ -291,5 +335,5 @@ def _add_helper(  # type: ignore[override]
         :type other1: BaseColumnPrimitiveTypeProfiler
         :type other2: BaseColumnPrimitiveTypeProfiler
         """
-        BaseColumnProfiler._add_helper(self, other1, other2)
+        super()._add_helper(other1, other2)
         self.match_count = other1.match_count + other2.match_count