psr-factory 5.0.0b16__py3-none-win_amd64.whl → 5.0.0b67__py3-none-win_amd64.whl

psr/factory/api.py

@@ -2,8 +2,10 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
+from __future__ import annotations
+
 import locale
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union, Any
 from types import ModuleType
 import copy
 import ctypes
@@ -16,6 +18,8 @@ import threading
 import pathlib
 import warnings
 
+from typing import TypeAlias
+
 from . import factorylib
 
 
@@ -30,6 +34,30 @@ pandas: Optional[ModuleType] = None
 polars: Optional[ModuleType] = None
 numpy: Optional[ModuleType] = None
 
+# Values returned by the library.
+ValueLike: TypeAlias = Union[
+    bool,
+    int,
+    float,
+    dt.datetime,
+    str,
+    "DataObject",
+    List[Any],
+    Dict[str, Any],
+    None,
+]
+
+PathLike: TypeAlias = Union[str, pathlib.Path]
+
+DateLike: TypeAlias = Union[str, dt.datetime]
+
+DataFrameLike: TypeAlias = Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]
+
+
+_default_dataframe_type: str = "pandas"
+
+_TYPES_WITHOUT_CONTEXT = ("Context", "ConvertOutputOptions", "DataFrameLoadOptions", "DataFrameSaveOptions", "DataFrameMetadata", "StudyLoadOptions", "StudySaveOptions")
+
 
 def _has_pandas() -> bool:
     """Check if pandas is available."""
@@ -68,10 +96,31 @@ def _has_polars() -> bool:
     return _HAS_POLARS
 
 
-# States whether the library is initialized.
-# It should be to correctly load and build models.
-_initialized = False
-_initialized_lock = threading.Lock()
+def set_default_dataframe_type(df_type: str):
+    """Set the default dataframe type to be used by the library."""
+    global _default_dataframe_type
+    df_type = df_type.lower()
+    if df_type not in ["pandas", "polars", "factory"]:
+        raise ValueError("Unsupported dataframe type. Supported types are 'pandas' and 'polars'.")
+    if df_type == "pandas" and not _has_pandas():
+        raise ValueError("Pandas is not installed. Please install it to use this dataframe type.")
+    if df_type == "polars" and not _has_polars():
+        raise ValueError("Polars is not installed. Please install it to use this dataframe type.")
+    _default_dataframe_type = df_type
+
+
+def get_default_dataframe_type() -> str:
+    """Get the default dataframe type used by the library."""
+    return _default_dataframe_type
+
+_basic_data_initialized = False
+_basic_data_initialized_lock = threading.Lock()
+
+_study_data_initialized = False
+_study_data_initialized_lock = threading.Lock()
+
+_constants_initialized = False
+_constants_initialized_lock = threading.Lock()
 
 _loaded = False
 _loaded_lock = threading.Lock()
@@ -80,16 +129,22 @@ _loaded_lock = threading.Lock()
 _preferred_encoding = locale.getpreferredencoding()
 
 # Internal date epoch
-# TODO: make it a library call.
-_date_transform = 12622780800
+_date_transform: Optional[int] = None
+
 
+def _check_basic_data_initialized():
+    """Checks if the module was initialized."""
+    global _basic_data_initialized
+    if not _basic_data_initialized:
+        _initialize_basic_data()
+    return _basic_data_initialized
 
-def _check_initialized():
+def _check_study_data_initialized():
     """Checks if the module was initialized."""
-    global _initialized
-    if not _initialized:
-        _initialize()
-    return _initialized
+    global _study_data_initialized
+    if not _study_data_initialized:
+        _initialize_study_data()
+    return _study_data_initialized
 
 
 def _check_loaded() -> bool:
@@ -119,6 +174,9 @@ def _bytes(value: str) -> int:
 class FactoryException(Exception):
     pass
 
+class FactoryLicenseError(Exception):
+    pass
+
 
 class LogLevel(enum.Enum):
     NOTSET = 0
@@ -168,11 +226,23 @@ def version() -> str:
     return _version_long()
 
 
-def build_version() -> str:
+def short_version() -> str:
     """Returns short library version."""
     return _version_short()
 
 
+def check_license() -> Tuple[bool, str]:
+    """Returns True if license is valid and active."""
+    _check_loaded()
+    error = Error()
+    factorylib.lib.psrd_check_license(error.handler())
+    valid = error.code == 0
+    invalid = error.code == 15
+    if not valid and not invalid:
+        raise FactoryException("Error checking license: " + error.what)
+    return valid, error.what
+
+
 def get_log_level() -> LogLevel:
     """Get log level."""
     _check_loaded()
@@ -222,9 +292,11 @@ def set_diagnostics_mode(value: Union[bool, int]):
 
 
 def diagnostics() -> str:
-    global _initialized
-    global _initialized_lock
-    with _initialized_lock:
+    global _basic_data_initialized
+    global _basic_data_initialized_lock
+    global _study_data_initialized
+    global _study_data_initialized_lock
+    with _basic_data_initialized_lock, _study_data_initialized_lock:
         """Get diagnostics information."""
         py_diagnostics = f"Python version: {sys.version}\n" \
                             f"Python encoding: {sys.getdefaultencoding()}\n" \
@@ -243,42 +315,49 @@ def diagnostics() -> str:
                                         buffer, size, error.handler())
         if error.code != 0:
             raise FactoryException(error.what)
-        _initialized = True
+        _basic_data_initialized = True
+        _study_data_initialized = True
         return py_diagnostics + _from_c_str(buffer.value)
 
 
-def get_setting(key: str) -> Union[str, int, float, bool]:
-    global _initialized
-    global _initialized_lock
-    with _initialized_lock:
-        _check_loaded()
-        error = Error()
-        value = Value()
-        factorylib.lib.psrd_get_global_setting(_c_str(key),
-                                               _bytes(key),
-                                               value.handler(),
-                                               error.handler())
-        if error.code != 0:
-            raise FactoryException(error.what)
-        return value.get()
+def get_constant(key: str) -> ValueLike:
+    _check_loaded()
+    error = Error()
+    value = Value()
+    factorylib.lib.psrd_get_constant(_c_str(key),
+                                           _bytes(key),
+                                           value.handler(),
+                                           error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
+    return value.get()
 
 
-def set_setting(key: str, value: Union[str, int, float, bool]):
-    global _initialized
-    global _initialized_lock
-    with _initialized_lock:
-        _check_loaded()
-        error = Error()
-        _value = Value()
-        _value.set(value)
-        factorylib.lib.psrd_set_global_setting(_c_str(key),
-                                               _bytes(key),
-                                               _value.handler(),
-                                               error.handler())
-        if error.code != 0:
-            raise FactoryException(error.what)
+def get_setting(key: str) -> ValueLike:
+    _check_loaded()
+    error = Error()
+    value = Value()
+    factorylib.lib.psrd_get_global_setting(_c_str(key),
+                                           _bytes(key),
+                                           value.handler(),
+                                           error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
+    return value.get()
 
 
+def set_setting(key: str, value: ValueLike):
+    _check_loaded()
+    error = Error()
+    _value = Value()
+    _value.set(value)
+    factorylib.lib.psrd_set_global_setting(_c_str(key),
+                                           _bytes(key),
+                                           _value.handler(),
+                                           error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
+
 
 def _get_context(models_or_context: Union[str, list, dict, "Context", None],
                  blocks: Optional[int] = None) -> "Value":
@@ -292,7 +371,7 @@ def _get_context(models_or_context: Union[str, list, dict, "Context", None],
         elif isinstance(models_or_context, str):
             context["Models"] = [models_or_context, ]
     else:
-        raise TypeError("Unexpected type for profile_or_context argument.")
+        raise TypeError("Unexpected type for model_or_context argument.")
     if blocks is not None and isinstance(blocks, int):
         if isinstance(blocks, Context):
             context.set("Blocks", blocks)
@@ -442,7 +521,7 @@ class ValueDict(_BaseObject):
         if self._hdr is not None:
             factorylib.lib.psrd_free_dict(self._hdr)
 
-    def __getitem__(self, key: Union["Value", bool, int, float, dt.datetime, str, "DataObject", list, dict, None]) -> Union["Value", bool, int, float, dt.datetime, str, "DataObject", list, dict, None]:
+    def __getitem__(self, key: ValueLike) -> ValueLike:
         if not isinstance(key, Value):
             old_key = key
             key = Value()
@@ -457,7 +536,7 @@ class ValueDict(_BaseObject):
             raise FactoryException(error.what)
         return value.get()
 
-    def __contains__(self, key: Union["Value", bool, int, float, dt.datetime, str, "DataObject", list, dict, None]) -> bool:
+    def __contains__(self, key: ValueLike) -> bool:
         if not isinstance(key, Value):
             old_key = key
             key = Value()
@@ -490,7 +569,7 @@ class ValueDict(_BaseObject):
         def __iter__(self):
             return self
 
-        def __next__(self) -> "Value":
+        def __next__(self) -> ValueLike:
             if self.index >= self.dict_obj.__len__():
                 raise StopIteration
             factorylib.lib.psrd_dict_get_key_by_index(self.dict_obj._hdr, self.index,
@@ -514,7 +593,7 @@ class ValueDict(_BaseObject):
         def __iter__(self):
             return self
 
-        def __next__(self) -> "Value":
+        def __next__(self) -> ValueLike:
             if self.index >= self.dict_obj.__len__():
                 raise StopIteration
             factorylib.lib.psrd_dict_get_value_by_index(self.dict_obj._hdr, self.index,
@@ -539,7 +618,7 @@ class ValueDict(_BaseObject):
         def __iter__(self):
             return self
 
-        def __next__(self) -> Tuple["Value", "Value"]:
+        def __next__(self) -> Tuple[ValueLike, ValueLike]:
             if self.index >= self.dict_obj.__len__():
                 raise StopIteration
             factorylib.lib.psrd_dict_get_by_index(self.dict_obj._hdr, self.index,
@@ -613,7 +692,7 @@ class Value(_BaseObject):
         if self._hdr is not None:
             factorylib.lib.psrd_free_value(self._hdr)
 
-    def get(self) -> Union[bool, int, float, dt.datetime, str, "DataObject", list, dict, None]:
+    def get(self) -> ValueLike:
         _err = Error()
         uint_value = ctypes.c_long()
         factorylib.lib.psrd_value_get_type(self._hdr,
@@ -631,13 +710,13 @@ class Value(_BaseObject):
                 raise FactoryException(_err.what)
             return int(int_value.value)
         elif var_type == ValueType.INT64.value:
-            long_value = ctypes.c_long()
+            long_value = ctypes.c_longlong()
             factorylib.lib.psrd_value_get_int64(self._hdr,
                                                 ctypes.byref(long_value),
                                                 _err.handler())
             if _err.code != 0:
                 raise FactoryException(_err.what)
-            return int(int_value.value)
+            return int(long_value.value)
         elif var_type == ValueType.FLOAT32.value:
             float_value = ctypes.c_float()
             factorylib.lib.psrd_value_get_float32(self._hdr,
@@ -670,7 +749,8 @@ class Value(_BaseObject):
                                                _err.handler())
             if _err.code != 0:
                 raise FactoryException(_err.what)
-
+            if _date_transform is None:
+                raise FactoryException("Factory is not initialized correctly.")
             return dt.datetime.fromtimestamp(date_value.value - _date_transform, dt.timezone.utc)
 
         elif var_type == ValueType.BOOL.value:
@@ -712,7 +792,7 @@ class Value(_BaseObject):
         else:
             raise NotImplementedError()
 
-    def set(self, value: Union[bool, int, float, dt.datetime, str, "DataObject", list, dict, None]):
+    def set(self, value: ValueLike):
         _err = Error()
         if isinstance(value, bool):
             factorylib.lib.psrd_value_set_bool(self._hdr, value,
@@ -720,6 +800,8 @@ class Value(_BaseObject):
             if _err.code != 0:
                 raise FactoryException(_err.what)
         elif isinstance(value, dt.datetime):
+            if _date_transform is None:
+                raise FactoryException("Factory is not initialized correctly.")
             value.replace(tzinfo=dt.timezone.utc)
             date_epoch = int(value.timestamp()) + _date_transform
             factorylib.lib.psrd_value_set_date(self._hdr, date_epoch,
@@ -784,7 +866,7 @@ class Value(_BaseObject):
                 raise FactoryException(_err.what)
 
         else:
-            raise FactoryException(f"Unsupported type \"{type(value).name}\" for value.")
+            raise FactoryException(f"Unsupported type \"{type(value).__name__}\" for value.")
 
 
 class PropertyDescription(_BaseObject):
@@ -799,11 +881,11 @@ class PropertyDescription(_BaseObject):
     @property
     def name(self) -> str:
         _err = Error()
-        # TODO: determine size automatically
-        size = 300
+        size = factorylib.lib.psrd_property_description_get_name(self._hdr, None, 0, _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
         buffer = ctypes.create_string_buffer(size)
-        factorylib.lib.psrd_property_description_get_name(self._hdr, buffer, size,
-                                                          _err.handler())
+        factorylib.lib.psrd_property_description_get_name(self._hdr, buffer, size, _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)
         return _from_c_str(buffer.value)
@@ -819,8 +901,9 @@ class PropertyDescription(_BaseObject):
     @property
     def alt_name(self) -> str:
         _err = Error()
-        # TODO: determine size automatically
-        size = 300
+        size = factorylib.lib.psrd_property_description_get_alternative_name(self._hdr, None, 0, _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
         buffer = ctypes.create_string_buffer(size)
         factorylib.lib.psrd_property_description_get_alternative_name(
             self._hdr, buffer, size, _err.handler())
@@ -836,6 +919,26 @@ class PropertyDescription(_BaseObject):
     def alt_name(self):
         raise AttributeError("do not delete alt_name")
 
+    def is_required(self) -> bool:
+        _err = Error()
+        value = ctypes.c_bool()
+        factorylib.lib.psrd_property_description_is_required(self._hdr,
+                                                            ctypes.byref(value),
+                                                            _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(value.value)
+
+    def is_reference(self) -> bool:
+        _err = Error()
+        value = ctypes.c_bool()
+        factorylib.lib.psrd_property_description_is_reference(self._hdr,
+                                                              ctypes.byref(value),
+                                                              _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(value.value)
+
     def is_dynamic(self) -> bool:
         _err = Error()
         value = ctypes.c_bool()
@@ -888,8 +991,9 @@ class PropertyDescription(_BaseObject):
         dimensions_count = int(value.value)
 
         for i_dim in range(dimensions_count):
-            # TODO: get size automatically
-            size = 100
+            size = factorylib.lib.psrd_property_description_get_dimension_name(self._hdr, i_dim, None, 0, _err.handler())
+            if _err.code != 0:
+                raise FactoryException(_err.what)
             buffer = ctypes.create_string_buffer(size)
             factorylib.lib.psrd_property_description_get_dimension_name(self._hdr,
                                                                         i_dim, buffer,
@@ -898,7 +1002,6 @@ class PropertyDescription(_BaseObject):
             if _err.code != 0:
                 raise FactoryException(_err.what)
             name = _from_c_str(buffer.value)
-
             factorylib.lib.psrd_property_description_get_dimension_size(self._hdr,
                                                                         i_dim,
                                                                         ctypes.byref(value),
@@ -931,7 +1034,6 @@ class PropertyDescription(_BaseObject):
             return f"Property {self.name} with dimensions {self.dimensions()}"
 
 
-
 class DataObject(_BaseObject):
     def __init__(self):
         super().__init__()
@@ -973,7 +1075,7 @@ class DataObject(_BaseObject):
         dest._hdr = ref
         return dest
 
-    def __deepcopy__(self, memodict=None):
+    def __deepcopy__(self, memo_dict=None):
         raise NotImplementedError()
 
     def __repr__(self):
@@ -994,7 +1096,8 @@ class DataObject(_BaseObject):
 
     @property
     def context(self) -> "Context":
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         obj = Context()
         _err = Error()
         ref = factorylib.lib.psrd_object_context(self._hdr,
@@ -1004,7 +1107,7 @@ class DataObject(_BaseObject):
         obj._hdr = ref
         return obj
 
-    def properties(self) -> Dict[str, PropertyDescription]:
+    def descriptions(self) -> Dict[str, PropertyDescription]:
         _err = Error()
         value = ctypes.c_long()
         factorylib.lib.psrd_object_property_description_count(self._hdr,
@@ -1025,7 +1128,30 @@ class DataObject(_BaseObject):
             properties[var.name] = var
         return properties
 
-    def get(self, expression: str) -> Union[int, float, dt.datetime, str, "DataObject", list, None]:
+    def description(self, name: str) -> Optional[PropertyDescription]:
+        _err = Error()
+        var = PropertyDescription()
+        ref = factorylib.lib.psrd_object_get_property_description_by_name(self._hdr,
+                                                                          _c_str(name),
+                                                                          _bytes(name),
+                                                                          _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        if ref is not None:
+            var._hdr = ref
+            return var
+        return None
+
+    def has_property(self, expression: str) -> bool:
+        _err = Error()
+        bool_value = ctypes.c_bool()
+        factorylib.lib.psrd_object_has_property(self._hdr, _c_str(expression), _bytes(expression),
+                                                ctypes.byref(bool_value), _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(bool_value.value)
+
+    def get(self, expression: str) -> ValueLike:
         value = Value()
         _err = Error()
         factorylib.lib.psrd_object_get_value(self._hdr,
@@ -1036,7 +1162,7 @@ class DataObject(_BaseObject):
             raise FactoryException(_err.what)
         return value.get()
 
-    def get_at(self, expression: str, range_expr: Union[str, dt.datetime]) -> Union[int, float, dt.datetime, str, "DataObject", list, None]:
+    def get_at(self, expression: str, range_expr: DateLike) -> ValueLike:
         if not isinstance(range_expr, (str, dt.datetime)):
             raise FactoryException("range_expr must be a string or datetime object.")
         _value = Value()
@@ -1052,7 +1178,7 @@ class DataObject(_BaseObject):
             raise FactoryException(_err.what)
         return _value.get()
 
-    def as_dict(self) -> Dict[str, any]:
+    def as_dict(self) -> Dict[str, ValueLike]:
         value_dict = ValueDict()
         error = Error()
         handler = factorylib.lib.psrd_object_get_as_dict(self._hdr,
@@ -1070,7 +1196,7 @@ class DataObject(_BaseObject):
         if error.code != 0:
             raise FactoryException(error.what)
 
-    def get_df(self, expression: str) -> "pandas.DataFrame":
+    def get_df(self, expression: str) -> DataFrameLike:
         _err = Error()
         _df = DataFrame()
         factorylib.lib.psrd_object_get_table(self._hdr, _df.handler(),
@@ -1081,7 +1207,7 @@ class DataObject(_BaseObject):
             raise FactoryException(_err.what)
         df_builder = _DataFrameBuilder()
         df_builder.build_dataframe(_df)
-        return df_builder.build_pandas_dataframe()
+        return df_builder.build_desired_dataframe_type()
 
     def set(self, expression: str, value):
         _err = Error()
@@ -1094,7 +1220,7 @@ class DataObject(_BaseObject):
         if _err.code != 0:
             raise FactoryException(_err.what)
 
-    def set_at(self, expression: str, range_expr: Union[str, dt.datetime], value):
+    def set_at(self, expression: str, range_expr: DateLike, value):
         if not isinstance(range_expr, (str, dt.datetime)):
             raise FactoryException("range_expr must be a string or datetime object.")
         _err = Error()
@@ -1200,6 +1326,34 @@ class DataObject(_BaseObject):
     def type(self):
         raise AttributeError("do not delete type")
 
+    @property
+    def key(self) -> str:
+        err = Error()
+        size = factorylib.lib.psrd_object_get_key(self._hdr, None,
+                                                  0, err.handler())
+        if err.code != 0:
+            raise FactoryException(err.what)
+        buffer = ctypes.create_string_buffer(size)
+        factorylib.lib.psrd_object_get_key(self._hdr, buffer,
+                                           size, err.handler())
+        if err.code == 0:
+            return _from_c_str(buffer.value)
+        raise FactoryException(err.what)
+
+    @key.setter
+    def key(self, value: str):
+        err = Error()
+        factorylib.lib.psrd_object_set_key(self._hdr,
+                                           _c_str(value),
+                                           _bytes(value),
+                                           err.handler())
+        if err.code != 0:
+            raise FactoryException(err.what)
+
+    @key.deleter
+    def key(self):
+        raise AttributeError("do not delete key")
+
     @property
     def name(self) -> str:
         err = Error()
@@ -1260,7 +1414,7 @@ class DataObject(_BaseObject):
 class Context(DataObject):
     @staticmethod
     def default_context() -> "Context":
-        _check_initialized()
+        _check_basic_data_initialized()
         context = Context()
         err = Error()
         ref = factorylib.lib.psrd_get_default_context(err.handler())
@@ -1310,7 +1464,7 @@ class Study(_BaseObject):
     def __copy__(self):
         raise NotImplementedError()
 
-    def __deepcopy__(self, memodict=None):
+    def __deepcopy__(self, memo_dict=None):
         dest = Study()
         _err = Error()
         ref = factorylib.lib.psrd_study_clone(self.handler(),
@@ -1321,7 +1475,8 @@ class Study(_BaseObject):
         return dest
 
     def create(self, object_type: str) -> DataObject:
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         return create(object_type, self.context)
 
 
@@ -1333,11 +1488,12 @@ class Study(_BaseObject):
         return copy.deepcopy(self)
 
     @staticmethod
-    def create_object(profile_or_context: Union[str, Context, dict, None],
+    def create_object(model_or_context: Union[str, Context, dict, None],
                       blocks: Optional[int] = None):
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         err = Error()
-        context = _get_context(profile_or_context, blocks)
+        context = _get_context(model_or_context, blocks)
         study = Study()
         study._hdr = factorylib.lib.psrd_study_create(context.handler(),
                                                       err.handler())
@@ -1346,15 +1502,16 @@ class Study(_BaseObject):
         return study
 
     @staticmethod
-    def load(study_path: Union[str, pathlib.Path], profile_or_context: Union[str, Context, None],
+    def load(study_path: PathLike, model_or_context: Union[str, Context, None],
              settings_only: bool = False,
              options: Optional[Union[dict, "Value", "DataObject"]] = None):
         if not isinstance(options, (DataObject, type(None))):
             raise TypeError("options must be a DataObject or None.")
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         study_path = str(study_path)
-        context = _get_context(profile_or_context, None)
-        err = Error()
+        context = _get_context(model_or_context, None)
+        error = Error()
         options_value = _get_arg_object(options)
         study = Study()
         if not settings_only:
@@ -1363,75 +1520,76 @@ class Study(_BaseObject):
             load_fn = factorylib.lib.psrd_study_load_settings
         study._hdr = load_fn(_c_str(study_path), _bytes(study_path),
                              options_value.handler(), context.handler(),
-                             err.handler())
-        if err.code != 0:
-            raise FactoryException(err.what)
+                             error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         return study
 
-    def save(self, output_path: Union[str, pathlib.Path],
+    def save(self, output_path: PathLike,
              options: Optional[Union[dict, Value, DataObject]] = None):
         output_path = str(output_path)
-        _err = Error()
+        error = Error()
         options_value = _get_arg_object(options)
         factorylib.lib.psrd_study_save(self._hdr,
                                        _c_str(output_path), _bytes(output_path),
                                        options_value.handler(),
-                                       _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                       error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
-    def save_settings(self, output_path: Union[str, pathlib.Path],
+    def save_settings(self, output_path: PathLike,
              options: Optional[Union[dict, Value, DataObject]] = None):
         output_path = str(output_path)
-        _err = Error()
+        error = Error()
         options_value = _get_arg_object(options)
         factorylib.lib.psrd_study_save_settings(self._hdr, _c_str(output_path),
                                                 _bytes(output_path),
                                                 options_value.handler(),
-                                                _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                                error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
     @property
     def context(self) -> "Context":
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         obj = Context()
-        _err = Error()
+        error = Error()
         ref = factorylib.lib.psrd_study_context(self._hdr,
-                                                _err.handler())
-        if _err.code != 0 or ref is None:
-            raise FactoryException(_err.what)
+                                                error.handler())
+        if error.code != 0 or ref is None:
+            raise FactoryException(error.what)
         obj._hdr = ref
         return obj
 
-    def get(self, expression: str) -> Union[int, float, dt.datetime, str, "DataObject", list, None]:
+    def get(self, expression: str) -> ValueLike:
         value = Value()
-        _err = Error()
+        error = Error()
         factorylib.lib.psrd_study_get_value(self._hdr,
                                             _c_str(expression),
                                             value.handler(),
-                                            _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                            error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         return value.get()
 
-    def get_at(self, expression: str, range_expr: Union[str, dt.datetime]) -> Union[int, float, dt.datetime, str, "DataObject", list, None]:
-        if not isinstance(range_expr, str):
+    def get_at(self, expression: str, range_expr: DateLike) -> ValueLike:
+        if not isinstance(range_expr, (str, dt.datetime)):
             raise FactoryException("range_expr must be a string or datetime object.")
-        _value = Value()
-        _err = Error()
-        _range = Value()
-        _range.set(range_expr)
+        value = Value()
+        error = Error()
+        range_value = Value()
+        range_value.set(range_expr)
         factorylib.lib.psrd_study_get_value_at(self._hdr,
                                                _c_str(expression),
-                                               _range.handler(),
-                                               _value.handler(),
-                                               _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
-        return _value.get()
+                                               range_value.handler(),
+                                               value.handler(),
+                                               error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        return value.get()
 
-    def as_dict(self) -> Dict[str, any]:
+    def as_dict(self) -> Dict[str, ValueLike]:
         value_dict = ValueDict()
         error = Error()
         handler = factorylib.lib.psrd_study_get_as_dict(self._hdr,
@@ -1452,22 +1610,22 @@ class Study(_BaseObject):
     def add(self, obj: DataObject):
         if not isinstance(obj, DataObject):
             raise TypeError("obj must be a DataObject.")
-        _err = Error()
+        error = Error()
         factorylib.lib.psrd_study_add(self._hdr,
                                       obj.handler(),
-                                      _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                      error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
     def remove(self, obj: DataObject):
         if not isinstance(obj, DataObject):
             raise TypeError("obj must be a DataObject.")
-        _err = Error()
+        error = Error()
         factorylib.lib.psrd_study_remove(self._hdr,
                                          obj.handler(),
-                                         _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                         error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
     def get_all_objects(self) -> List[DataObject]:
         object_list = ValueList(False)
@@ -1479,185 +1637,232 @@ class Study(_BaseObject):
         object_list._hdr = ref
         return object_list.to_list()
 
+    def get_by_key(self) -> Optional[DataObject]:
+        object_value = Value()
+        error = Error()
+        factorylib.lib.psrd_study_get_object_by_key(self._hdr,
+                                                    object_value.handler(),
+                                                    error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        obj = object_value.get()
+        if isinstance(obj, DataObject):
+            return obj
+        return None
+
+    def get_key_object_map(self) -> Dict[str, DataObject]:
+        object_dict = ValueDict()
+        error = Error()
+        ref = factorylib.lib.psrd_study_get_key_object_map(self._hdr,
+                                                           error.handler())
+        if error.code != 0 or ref is None:
+            raise FactoryException(error.what)
+        object_dict._hdr = ref
+        result = {}
+        for key, value in object_dict.to_dict().items():
+            if isinstance(value, DataObject):
+                result[key] = value
+        return result
+
     def find(self, expression: str) -> List[DataObject]:
         object_list = ValueList(False)
-        _err = Error()
-        ref = factorylib.lib.psrd_study_find(self._hdr,
+        error = Error()
+        handler = factorylib.lib.psrd_study_find(self._hdr,
                                              _c_str(expression),
-                                             _err.handler())
-        if _err.code != 0 or ref is None:
-            raise FactoryException(_err.what)
-        object_list._hdr = ref
+                                             error.handler())
+        if error.code != 0 or handler is None:
+            raise FactoryException(error.what)
+        object_list._hdr = handler
         return object_list.to_list()
 
-    def find_by_name(self, type_name: str, name: Optional[str] = None) -> List[DataObject]:
-        if name is None:
-            warnings.warn(DeprecationWarning("Starting from Factory 4.0.28 "
-                                             "the second argument 'name' must be provided.\n"
-                                             "Use find_by_name(type_name, name)"))
-
-        type_name, name_str = type_name.split(".", 1)
-        name = name_str
+    def find_by_name(self, type_name: str, name_or_pattern: str) -> List[DataObject]:
+        if name_or_pattern is None or name_or_pattern == "":
+            raise DeprecationWarning("Starting from Factory 4.0.28 "
+                                     "the second argument 'name_or_pattern' must be provided.\n"
+                                     "Use find_by_name(type_name, name_or_pattern)")
         object_list = ValueList(False)
-        _err = Error()
-        if name.strip() == "":
-            name = "*"
-        expression = f"{type_name}.{name}"
-        ref = factorylib.lib.psrd_study_find(self._hdr,
-                                             _c_str(expression),
-                                             _err.handler())
-        if _err.code != 0 or ref is None:
-            raise FactoryException(_err.what)
-        object_list._hdr = ref
+        error = Error()
+        expression = f"{type_name}.{name_or_pattern}"
+        handler = factorylib.lib.psrd_study_find(self._hdr,
+                                                 _c_str(expression),
+                                                 error.handler())
+        if error.code != 0 or handler is None:
+            raise FactoryException(error.what)
+        object_list._hdr = handler
         return object_list.to_list()
 
-    def find_by_code(self, type_name: str, code: Optional[int] = None) -> List[DataObject]:
+    def find_by_code(self, type_name: str, code: int) -> List[DataObject]:
         if code is None:
-            warnings.warn(DeprecationWarning("Starting from Factory 4.0.9 "
-                                             "the second argument 'code' must be provided.\n"
-                                             "Use find_by_code(type_name, code)"))
-
-            type_name, code_str = type_name.split(".", 1)
-            code = int(code_str)
+            raise DeprecationWarning("Starting from Factory 4.0.9 "
+                                     "the second argument 'code' must be provided.\n"
+                                     "Use find_by_code(type_name, code)")
 
         object_list = ValueList(False)
-        _err = Error()
-        ref = factorylib.lib.psrd_study_find_by_code(self._hdr,
-                                                     _c_str(type_name),
-                                                     code,
-                                                     _err.handler())
-        if _err.code != 0 or ref is None:
-            raise FactoryException(_err.what)
-        object_list._hdr = ref
+        error = Error()
+        handler = factorylib.lib.psrd_study_find_by_code(self._hdr,
+                                                         _c_str(type_name),
+                                                         code,
+                                                         error.handler())
+        if error.code != 0 or handler is None:
+            raise FactoryException(error.what)
+        object_list._hdr = handler
         return object_list.to_list()
 
-    def find_by_id(self, expression: str) -> List[DataObject]:
+    def find_by_id(self, type_name: str, id_or_pattern: str) -> List[DataObject]:
+        if id_or_pattern is None or id_or_pattern == "":
+            raise DeprecationWarning("Starting from Factory 5.0.0 "
+                                     "the second argument 'id' must be provided.\n"
+                                     "Use find_by_id(type_name, id)")
+        expression = f"{type_name}.{id_or_pattern}"
         object_list = ValueList(False)
-        _err = Error()
+        error = Error()
         ref = factorylib.lib.psrd_study_find_by_id(self._hdr,
                                                    _c_str(expression),
-                                                   _err.handler())
-        if _err.code != 0 or ref is None:
-            raise FactoryException(_err.what)
+                                                   error.handler())
+        if error.code != 0 or ref is None:
+            raise FactoryException(error.what)
         object_list._hdr = ref
         return object_list.to_list()
 
-    def set(self, expression: str, value):
-        _err = Error()
-        _val = Value()
-        _val.set(value)
+    def set(self, expression: str, value: ValueLike):
+        error = Error()
+        value_object = Value()
+        value_object.set(value)
         factorylib.lib.psrd_study_set_value(self._hdr,
                                             _c_str(expression),
                                             _bytes(expression),
-                                            _val.handler(),
-                                            _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                            value_object.handler(),
+                                            error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
-    def set_at(self, expression: str, range_expr: Union[str, dt.datetime], value):
+    def set_at(self, expression: str, range_expr: DateLike, value: ValueLike):
         if not isinstance(range_expr, (str, dt.datetime)):
             raise FactoryException("range_expr must be a string or datetime object.")
-        _err = Error()
-        _value = Value()
-        _value.set(value)
-        _range = Value()
-        _range.set(range_expr)
+        error = Error()
+        value_object = Value()
+        value_object.set(value)
+        range_value = Value()
+        range_value.set(range_expr)
         factorylib.lib.psrd_study_set_value_at(self._hdr,
                                                _c_str(expression),
                                                _bytes(expression),
-                                               _range.handler(),
-                                               _value.handler(),
-                                               _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                               range_value.handler(),
+                                               value_object.handler(),
+                                               error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
-    def get_df(self, expression: str) -> "pandas.DataFrame":
-        _err = Error()
-        _df = DataFrame()
-        factorylib.lib.psrd_study_get_table(self._hdr, _df.handler(),
+    def get_df(self, expression: str) -> DataFrameLike:
+        error = Error()
+        df = DataFrame()
+        factorylib.lib.psrd_study_get_table(self._hdr, df.handler(),
                                             _c_str(expression),
                                             _bytes(expression),
-                                            _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                            error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         df_builder = _DataFrameBuilder()
-        df_builder.build_dataframe(_df)
-        return df_builder.build_pandas_dataframe()
+        df_builder.build_dataframe(df)
+        return df_builder.build_desired_dataframe_type()
 
-    def get_objects_values(self, object_type: str, columns: List[str]) -> "pandas.DataFrame":
-        _err = Error()
-        _table = DataFrame()
+    def get_objects_values(self, object_type: str, columns: List[str]) -> DataFrameLike:
+        error = Error()
+        df = DataFrame()
         columns_list = Value()
         columns_list.set(columns)
-        factorylib.lib.psrd_study_get_objects_values(self._hdr, _table.handler(),
+        factorylib.lib.psrd_study_get_objects_values(self._hdr, df.handler(),
                                                      _c_str(object_type),
                                                      columns_list.handler(),
-                                                     _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                                     error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         df_builder = _DataFrameBuilder()
-        df_builder.build_dataframe(_table)
-        return df_builder.build_pandas_dataframe()
+        df_builder.build_dataframe(df)
+        return df_builder.build_desired_dataframe_type()
 
-    def get_objects_values_at(self, object_type: str, columns: List[str], range: Union[str, dt.datetime]) -> "pandas.DataFrame":
-        _err = Error()
-        _df = DataFrame()
-        _range = Value()
-        _range.set(range)
+    def get_objects_values_at(self, object_type: str, columns: List[str], range_value: DateLike) -> DataFrameLike:
+        error = Error()
+        df = DataFrame()
+        range_object = Value()
+        range_object.set(range_value)
         columns_list = Value()
         columns_list.set(columns)
-        factorylib.lib.psrd_study_get_objects_values_at(self._hdr, _df.handler(),
+        factorylib.lib.psrd_study_get_objects_values_at(self._hdr, df.handler(),
                                                         _c_str(object_type),
                                                         columns_list.handler(),
-                                                        _range.handler(),
-                                                        _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                                        range_object.handler(),
+                                                        error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         df_builder = _DataFrameBuilder()
-        df_builder.build_dataframe(_df)
-        return df_builder.build_pandas_dataframe()
+        df_builder.build_dataframe(df)
+        return df_builder.build_desired_dataframe_type()
 
-    def properties(self) -> Dict[str, PropertyDescription]:
-        _err = Error()
+    def descriptions(self) -> Dict[str, PropertyDescription]:
+        error = Error()
         value = ctypes.c_long()
         factorylib.lib.psrd_study_property_description_count(self._hdr,
                                                              ctypes.byref(value),
-                                                             _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                                             error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         var_count = int(value.value)
         properties = {}
         for i_var in range(var_count):
             var = PropertyDescription()
             ref = factorylib.lib.psrd_study_get_property_description(self._hdr,
                                                                      i_var,
-                                                                     _err.handler())
-            if _err.code != 0 or ref is None:
-                raise FactoryException(_err.what)
+                                                                     error.handler())
+            if error.code != 0 or ref is None:
+                raise FactoryException(error.what)
             var._hdr = ref
             properties[var.name] = var
         return properties
 
+    def description(self, name: str) -> Optional[PropertyDescription]:
+        _err = Error()
+        var = PropertyDescription()
+        ref = factorylib.lib.psrd_study_get_property_description_by_name(self._hdr,
+                                                                         _c_str(name),
+                                                                         _bytes(name),
+                                                                         _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        if ref is not None:
+            var._hdr = ref
+            return var
+        return None
+
+    def has_property(self, expression: str) -> bool:
+        _err = Error()
+        bool_value = ctypes.c_bool()
+        factorylib.lib.psrd_study_has_property(self._hdr, _c_str(expression), _bytes(expression),
+                                               ctypes.byref(bool_value), _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(bool_value.value)
+
     def set_df(self, dataframe_like):
         if not _has_pandas():
             raise ModuleNotFoundError("pandas required.")
         dataframe_like = pandas.api.interchange.from_dataframe(dataframe_like)
         df_builder = _DataFrameBuilder()
-        _df = df_builder.build_from_pandas(dataframe_like)
-        _err = Error()
-        factorylib.lib.psrd_study_set_table(self._hdr, _df.handler(),
-                                            _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+        df = df_builder.build_from_pandas(dataframe_like)
+        error = Error()
+        factorylib.lib.psrd_study_set_table(self._hdr, df.handler(),
+                                            error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
     def clear_values(self, expression: str):
-        _err = Error()
+        error = Error()
         factorylib.lib.psrd_study_clear_values(self._hdr,
                                                _c_str(expression),
                                                _bytes(expression),
-                                               _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                               error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
 
 def _is_int64(value):
@@ -1670,6 +1875,40 @@ def _is_float64(value):
     return isinstance(value, (numpy.float64, float)) or (isinstance(value, numpy.ndarray) and value.dtype == numpy.float64)
 
 
+def _pandas_dtype_to_column_type(dtype: str) -> int:
+    if dtype == "object":
+        return 0
+    elif dtype == "int32":
+        return 1
+    elif dtype == "int64":
+        return 2
+    elif dtype == "float32":
+        return 3
+    elif dtype == "float64":
+        return 4
+    elif dtype == "string":
+        return 5
+    elif dtype == "datetime64[ns]":
+        return 6
+    else:
+        raise FactoryException(f"Unsupported pandas dtype \"{dtype}\".")
+
+
+def _polars_dtype_to_column_type(dtype: "polars.datatypes.classes.DataTypeClass") -> int:
+    if dtype == polars.Int32:
+        return 1
+    if dtype == polars.Int64:
+        return 2
+    if dtype == polars.Float64:
+        return 3
+    if dtype == polars.Float64:
+        return 4
+    if dtype == polars.String:
+        return 5
+    else:
+        raise FactoryException(f"Unsupported polars dtype \"{dtype}\".")
+
+
 class _DataFrameBuilder:
     def __init__(self):
         self.indices: List[Optional[_TableColumn]] = []
@@ -1680,67 +1919,34 @@ class _DataFrameBuilder:
         self.index_types: List[int] = []
         self._not_built = True
         self._value: Optional[Value] = None
-        self._err: Optional[Error] = None
-
-    def _pandas_dtype_to_column_type(self, dtype: str) -> int:
-        if dtype == "object":
-            return 0
-        elif dtype == "int32":
-            return 1
-        elif dtype == "int64":
-            return 2
-        elif dtype == "float32":
-            return 3
-        elif dtype == "float64":
-            return 4
-        elif dtype == "string":
-            return 5
-        elif dtype == "datetime64[ns]":
-            return 6
-        else:
-            raise FactoryException(f"Unsupported pandas dtype \"{dtype}\".")
-
-    def _polars_dtype_to_column_type(self, dtype: "polars.datatypes.classes.DataTypeClass") -> int:
-        if dtype == polars.Int32:
-            return 1
-        if dtype == polars.Int64:
-            return 2
-        if dtype == polars.Float64:
-            return 3
-        if dtype == polars.Float64:
-            return 4
-        if dtype == polars.String:
-            return 5
-        else:
-            raise FactoryException(f"Unsupported polars dtype \"{dtype}\".")
-
+        self._error: Optional[Error] = None
 
     def build_dataframe(self, df: "DataFrame"):
-        self._err = Error()
+        self._error = Error()
         name_buffer_length = 200
-        _columns_count = ctypes.c_long()
+        columns_count = ctypes.c_long()
         factorylib.lib.psrd_table_columns_count(df.handler(),
-                                                ctypes.byref(_columns_count),
-                                                self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        columns_count = _columns_count.value
+                                                ctypes.byref(columns_count),
+                                                self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        columns_count = columns_count.value
 
-        _rows_count = ctypes.c_long()
+        rows_count = ctypes.c_long()
         factorylib.lib.psrd_table_rows_count(df.handler(),
-                                             ctypes.byref(_rows_count),
-                                             self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        rows_count = _rows_count.value
+                                             ctypes.byref(rows_count),
+                                             self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        rows_count = rows_count.value
 
-        _indices_count = ctypes.c_long()
+        indices_count = ctypes.c_long()
         factorylib.lib.psrd_table_index_count(df.handler(),
-                                              ctypes.byref(_indices_count),
-                                              self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        indices_count = _indices_count.value
+                                              ctypes.byref(indices_count),
+                                              self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        indices_count = indices_count.value
 
         value = Value()
         buffer = ctypes.create_string_buffer(name_buffer_length)
@@ -1749,27 +1955,27 @@ class _DataFrameBuilder:
         for index in range(indices_count):
             factorylib.lib.psrd_table_index_get_name(df.handler(), index,
                                                      buffer, name_buffer_length,
-                                                     self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                     self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
             self.indices[index].name = _from_c_str(buffer.value)
 
             self.indices[index].values = [None] * rows_count
             for i_row in range(0, rows_count):
                 factorylib.lib.psrd_table_index_get_value(df.handler(), index,
                                                           i_row, value.handler(),
-                                                          self._err.handler())
-                if self._err.code != 0:
-                    raise FactoryException(self._err.what)
+                                                          self._error.handler())
+                if self._error.code != 0:
+                    raise FactoryException(self._error.what)
                 self.indices[index].values[i_row] = value.get()
 
         self.columns = [_TableColumn() for _ in range(columns_count)]
         for column in range(columns_count):
             factorylib.lib.psrd_table_column_get_name(df.handler(), column,
                                                       buffer, name_buffer_length,
-                                                      self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                      self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
             self.columns[column].name = _from_c_str(buffer.value)
 
             self.columns[column].values = [None] * rows_count
@@ -1777,38 +1983,38 @@ class _DataFrameBuilder:
                 factorylib.lib.psrd_table_column_get_value(df.handler(),
                                                            column, row,
                                                            value.handler(),
-                                                           self._err.handler())
-                if self._err.code != 0:
-                    raise FactoryException(self._err.what)
+                                                           self._error.handler())
+                if self._error.code != 0:
+                    raise FactoryException(self._error.what)
                 self.columns[column].values[row] = value.get()
         self._not_built = False
 
     def build_dataframe_of_integral_types(self, df: "DataFrame"):
-        self._err = Error()
+        self._error = Error()
         name_buffer_length = 200
-        _columns_count = ctypes.c_long()
+        columns_count = ctypes.c_long()
         factorylib.lib.psrd_table_columns_count(df.handler(),
-                                                ctypes.byref(_columns_count),
-                                                self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        columns_count = _columns_count.value
+                                                ctypes.byref(columns_count),
+                                                self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        columns_count = columns_count.value
 
-        _rows_count = ctypes.c_long()
+        rows_count = ctypes.c_long()
         factorylib.lib.psrd_table_rows_count(df.handler(),
-                                             ctypes.byref(_rows_count),
-                                             self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        rows_count = _rows_count.value
+                                             ctypes.byref(rows_count),
+                                             self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        rows_count = rows_count.value
 
-        _indices_count = ctypes.c_long()
+        indices_count = ctypes.c_long()
         factorylib.lib.psrd_table_index_count(df.handler(),
-                                              ctypes.byref(_indices_count),
-                                              self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
-        indices_count = _indices_count.value
+                                              ctypes.byref(indices_count),
+                                              self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
+        indices_count = indices_count.value
 
         buffer = ctypes.create_string_buffer(name_buffer_length)
 
@@ -1816,9 +2022,9 @@ class _DataFrameBuilder:
         for index in range(indices_count):
             factorylib.lib.psrd_table_index_get_name(df.handler(), index,
                                                      buffer, name_buffer_length,
-                                                     self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                     self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
             index_name = _from_c_str(buffer.value)
             self.indices[index].name = index_name
             self.indices[index].values = [None] * rows_count
@@ -1827,40 +2033,52 @@ class _DataFrameBuilder:
                 factorylib.lib.psrd_table_index_get_date_values(df.handler(),
                                                                 index,
                                                                 array_values,
-                                                                self._err.handler())
-                if self._err.code != 0:
-                    raise FactoryException(self._err.what)
+                                                                self._error.handler())
+                if self._error.code != 0:
+                    raise FactoryException(self._error.what)
                 # convert array values to python datetime
+                if _date_transform is None:
+                    raise FactoryException("Factory is not initialized correctly.")
                 self.indices[index].values = [dt.datetime.fromtimestamp(value - _date_transform, dt.UTC) for value in array_values]
             else:
                 array_values = (ctypes.c_int * rows_count)()
                 factorylib.lib.psrd_table_index_get_int32_values(df.handler(),
                                                                  index,
                                                                  array_values,
-                                                                 self._err.handler())
-                if self._err.code != 0:
-                    raise FactoryException(self._err.what)
+                                                                 self._error.handler())
+                if self._error.code != 0:
+                    raise FactoryException(self._error.what)
                 self.indices[index].values = array_values
 
         self.columns = [_TableColumn() for _ in range(columns_count)]
         for column in range(columns_count):
             factorylib.lib.psrd_table_column_get_name(df.handler(), column,
                                                       buffer, name_buffer_length,
-                                                      self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                      self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
             self.columns[column].name = _from_c_str(buffer.value)
 
             array_values = (ctypes.c_double * rows_count)()
             factorylib.lib.psrd_table_column_get_float64_values(df.handler(),
                                                                 column,
                                                                 array_values,
-                                                                self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                                self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
             self.columns[column].values = array_values
         self._not_built = False
 
+    def build_desired_dataframe_type(self, **kwargs) -> DataFrameLike:
+        if _default_dataframe_type == "pandas":
+            return self.build_pandas_dataframe(**kwargs)
+        elif _default_dataframe_type == "polars":
+            return self.build_polars_dataframe(**kwargs)
+        elif _default_dataframe_type == "factory":
+            raise NotImplementedError("Returning a psr.factory.DataFrame not implemented yet.")
+        else:
+            raise FactoryException(f"Unsupported default dataframe type \"{_default_dataframe_type}\".")
+
     def build_pandas_dataframe(self, **kwargs) -> "pandas.DataFrame":
         use_object_dtype = kwargs.get("use_object_dtype", True)
         if not _has_pandas():
@@ -1905,16 +2123,18 @@ class _DataFrameBuilder:
             table_data_indices = []
 
         self.column_names = table_data.columns
+        if len(self.column_names) != len(set(self.column_names)):
+            raise FactoryException("DataFrame contains repeated column names.")
         self.index_names = [index.name for index in table_data_indices]
-        self.column_types = [self._pandas_dtype_to_column_type(dtype) for dtype in table_data.dtypes]
-        self.index_types = [self._pandas_dtype_to_column_type(index.dtype) for index in table_data_indices]
+        self.column_types = [_pandas_dtype_to_column_type(dtype) for dtype in table_data.dtypes]
+        self.index_types = [_pandas_dtype_to_column_type(index.dtype) for index in table_data_indices]
         replaced_name = False
         for i, name in enumerate(self.index_names):
             if name is None:
                 self.index_names[i] = 'date'
                 replaced_name = True
         rows = len(table_data.index)
-        _df = self._pre_build_generic(rows, self.index_types, self.column_types)
+        df = self._pre_build_generic(rows, self.index_types, self.column_types)
 
         test_conversion_types = {
             pandas.api.types.is_integer_dtype: numpy.int32,
@@ -1945,9 +2165,9 @@ class _DataFrameBuilder:
                     break
 
         if replaced_name:
-            for i, name in enumerate(self.index_names):
+            for i_index, name in enumerate(self.index_names):
                 if name == "date":
-                    self.index_names[i] = None
+                    self.index_names[i_index] = None
         # check index value types
         index_convert_to = {}
         index_fast_set = {}
@@ -1980,61 +2200,63 @@ class _DataFrameBuilder:
                     # TODO: check if original dataframe values is unaltered
                     index_values = index_values.astype('datetime64[s]').astype(dt.datetime)
                     # for each value, convert to timestamp
+                    if _date_transform is None:
+                        raise FactoryException("Factory is not initialized correctly.")
                     for ix, x in enumerate(index_values):
                         index_values[ix] = int(x.replace(tzinfo=dt.timezone.utc).timestamp() + _date_transform)
                     # convert to int64
                     index_values = index_values.astype(numpy.int64)
                     ptr = index_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_index_set_date_values(_df.handler(),
+                    factorylib.lib.psrd_table_index_set_date_values(df.handler(),
                                                                     i_index,
                                                                     ptr,
-                                                                    self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                    self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.int32:
                     ptr = index_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_index_set_int32_values(_df.handler(),
+                    factorylib.lib.psrd_table_index_set_int32_values(df.handler(),
                                                                      i_index,
                                                                      ptr,
-                                                                     self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                     self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.int64:
                     ptr = index_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_index_set_int64_values(_df.handler(),
+                    factorylib.lib.psrd_table_index_set_int64_values(df.handler(),
                                                                      i_index,
                                                                      ptr,
-                                                                     self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                     self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.float32:
                     ptr = index_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_index_set_float32_values(_df.handler(),
-                                                                        i_index,
-                                                                        ptr,
-                                                                        self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                    factorylib.lib.psrd_table_index_set_float32_values(df.handler(),
+                                                                       i_index,
+                                                                       ptr,
+                                                                       self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.float64:
                     ptr = index_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_index_set_float64_values(_df.handler(),
+                    factorylib.lib.psrd_table_index_set_float64_values(df.handler(),
                                                                        i_index,
                                                                        ptr,
-                                                                       self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                       self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 else:
                     raise FactoryException("Unsupported index type: " + str(convert_to_type))
             else:
                 for i_row, column_value in enumerate(index_values):
                     self._value.set(column_value)
-                    factorylib.lib.psrd_table_index_set_value(_df.handler(),
+                    factorylib.lib.psrd_table_index_set_value(df.handler(),
                                                               i_index,
                                                               i_row,
                                                               self._value.handler(),
-                                                              self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                              self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
 
         for i_column, column_name in enumerate(self.column_names):
             if column_name in column_convert_to.keys():
@@ -2045,49 +2267,48 @@ class _DataFrameBuilder:
             if column_name in column_fast_set.keys() and column_fast_set[column_name]:
                 if convert_to_type == numpy.float32:
                     ptr = column_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_column_set_float32_values(_df.handler(),
+                    factorylib.lib.psrd_table_column_set_float32_values(df.handler(),
                                                                         i_column,
                                                                         ptr,
-                                                                        self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.code)
+                                                                        self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.code)
                 if convert_to_type == numpy.float64:
                     ptr = column_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_column_set_float64_values(_df.handler(),
+                    factorylib.lib.psrd_table_column_set_float64_values(df.handler(),
                                                                         i_column,
                                                                         ptr,
-                                                                        self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                        self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.int32:
                     ptr = column_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_column_set_int32_values(_df.handler(),
+                    factorylib.lib.psrd_table_column_set_int32_values(df.handler(),
                                                                       i_column,
                                                                       ptr,
-                                                                      self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                      self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
                 elif convert_to_type == numpy.int64:
                     ptr = column_values.ctypes.data_as(ctypes.POINTER(convert_to_ctype[convert_to_type]))
-                    factorylib.lib.psrd_table_column_set_int64_values(_df.handler(),
+                    factorylib.lib.psrd_table_column_set_int64_values(df.handler(),
                                                                       i_column,
                                                                       ptr,
-                                                                      self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
+                                                                      self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
             else:
                 column_values = table_data[column_name]
                 for i_row, column_value in enumerate(column_values):
                     self._value.set(column_value)
-                    factorylib.lib.psrd_table_column_set_value(_df.handler(),
+                    factorylib.lib.psrd_table_column_set_value(df.handler(),
                                                                i_column,
                                                                i_row,
                                                                self._value.handler(),
-                                                               self._err.handler())
-                    if self._err.code != 0:
-                        raise FactoryException(self._err.what)
-        return _df
-
+                                                               self._error.handler())
+                    if self._error.code != 0:
+                        raise FactoryException(self._error.what)
+        return df
 
     def build_polars_dataframe(self, **kwargs) -> "polars.DataFrame":
         use_object_dtype = kwargs.get("use_object_dtype", True)
@@ -2110,75 +2331,76 @@ class _DataFrameBuilder:
 
     def build_from_polars(self, table_data: "polars.DataFrame") -> "DataFrame":
         # check if the table has indices and if its multi-index or common index
-        _index_names = ("year", "week", "month", "hour", "scenario", "block", "stage")
+        index_names = ("year", "week", "month", "hour", "scenario", "block", "stage")
         column_index = 0
         data_columns = table_data.columns[:]
+        if len(self.column_names) != len(set(self.column_names)):
+            raise FactoryException("DataFrame contains repeated column names.")
         index_columns = []
         while column_index < len(data_columns):
-            if data_columns[column_index] in _index_names:
+            if data_columns[column_index] in index_names:
                 index_columns.append(data_columns.pop(column_index))
                 continue
             column_index += 1
-        self.column_types = [self._polars_dtype_to_column_type(table_data[column_name].dtype) for column_name in data_columns]
-        self.index_types = [self._polars_dtype_to_column_type(table_data[index_name].dtype) for index_name in index_columns]
+        self.column_types = [_polars_dtype_to_column_type(table_data[column_name].dtype) for column_name in data_columns]
+        self.index_types = [_polars_dtype_to_column_type(table_data[index_name].dtype) for index_name in index_columns]
 
         self.column_names = data_columns
         self.index_names = index_columns
         rows = table_data.height
-        _df = self._pre_build_generic(rows, self.index_types, self.column_types)
+        df = self._pre_build_generic(rows, self.index_types, self.column_types)
 
         for i_row, all_row_values in enumerate(table_data.iter_rows()):
             index = all_row_values[:len(index_columns)]
             row_values = all_row_values[len(index_columns):]
-            self._set_row_values(_df, i_row, index, row_values)
-        return _df
+            self._set_row_values(df, i_row, index, row_values)
+        return df
 
     def _pre_build_generic(self, rows: int, index_types: List[int], column_types: List[int]) -> "DataFrame":
-        _df = DataFrame()
-        self._err = Error()
+        df = DataFrame()
+        self._error = Error()
         self._value = Value()
 
-        factorylib.lib.psrd_table_resize(_df.handler(), rows,
-                                         self._err.handler())
-        if self._err.code != 0:
-            raise FactoryException(self._err.what)
+        factorylib.lib.psrd_table_resize(df.handler(), rows,
+                                         self._error.handler())
+        if self._error.code != 0:
+            raise FactoryException(self._error.what)
 
         for i_index, index_type in enumerate(index_types):
-            factorylib.lib.psrd_table_configure_index(_df.handler(),
+            factorylib.lib.psrd_table_configure_index(df.handler(),
                                                       i_index,
                                                       index_type,
-                                                      self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                      self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
         for i_column, column_type in enumerate(column_types):
-            factorylib.lib.psrd_table_configure_column(_df.handler(),
+            factorylib.lib.psrd_table_configure_column(df.handler(),
                                                        i_column,
                                                        column_type,
-                                                       self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                       self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
 
         # Set column names
         for i_column, column_name in enumerate(self.column_names):
-            factorylib.lib.psrd_table_column_set_name(_df.handler(),
+            factorylib.lib.psrd_table_column_set_name(df.handler(),
                                                       i_column,
                                                       _c_str(column_name),
                                                       _bytes(column_name),
-                                                      self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                      self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
 
         # Set index names
         for i_index, index_name in enumerate(self.index_names):
-            factorylib.lib.psrd_table_index_set_name(_df.handler(),
+            factorylib.lib.psrd_table_index_set_name(df.handler(),
                                                      i_index,
                                                      _c_str(index_name),
                                                      _bytes(index_name),
-                                                     self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
-
-        return _df
+                                                     self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
+        return df
 
     def _set_row_values(self, df: "DataFrame", i_row: int, index_values: List[Union[int, float, str]], column_values: List[Union[int, float, str]]):
         self._value = Value()
@@ -2188,9 +2410,9 @@ class _DataFrameBuilder:
                                                       i_index,
                                                       i_row,
                                                       self._value.handler(),
-                                                      self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                      self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
 
         for i_column, column_value in enumerate(column_values):
             self._value.set(column_value)
@@ -2198,9 +2420,9 @@ class _DataFrameBuilder:
                                                        i_column,
                                                        i_row,
                                                        self._value.handler(),
-                                                       self._err.handler())
-            if self._err.code != 0:
-                raise FactoryException(self._err.what)
+                                                       self._error.handler())
+            if self._error.code != 0:
+                raise FactoryException(self._error.what)
 
 
 class DataFrame(_BaseObject):
@@ -2214,25 +2436,28 @@ class DataFrame(_BaseObject):
             factorylib.lib.psrd_free_table(self._hdr)
 
     @staticmethod
-    def load_from_file(input_file: Union[str, pathlib.Path], options: Optional[Union[dict, Value, DataObject]] = None) -> "DataFrame":
+    def load_from_file(input_file: PathLike, options: Optional[Union[dict, Value, DataObject]] = None) -> "DataFrame":
         input_file = str(input_file)
-        _check_initialized()
-        _err = Error()
-        table = DataFrame()
+        _check_basic_data_initialized()
+        error = Error()
+        df = DataFrame()
         options_value = _get_arg_object(options)
-        factorylib.lib.psrd_table_load(table.handler(),
+        factorylib.lib.psrd_table_load(df.handler(),
                                        _c_str(input_file),
                                        _bytes(input_file),
                                        options_value.handler(),
-                                       _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
-        return table
+                                       error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        return df
 
     @staticmethod
-    def from_dataframe(df: Union["pandas.DataFrame", "polars.DataFrame"], **kwargs) -> "DataFrame":
-        _check_initialized()
+    def from_dataframe(df: DataFrameLike) -> "DataFrame":
+        _check_basic_data_initialized()
         df_builder = _DataFrameBuilder()
+        if isinstance(df, DataFrame):
+            # FIXME: implement this
+            raise NotImplementedError("Creating a DataFrame from another psr.factory.DataFrame is not implemented.")
         if _has_pandas() and isinstance(df, pandas.DataFrame):
             dataframe_like = pandas.api.interchange.from_dataframe(df)
             return df_builder.build_from_pandas(dataframe_like)
@@ -2242,16 +2467,16 @@ class DataFrame(_BaseObject):
             return df_builder.build_from_polars(dataframe_like)
         raise ImportError("Pandas or polars is not available. Please install pandas to use this feature.")
 
-    def save(self, output_file: Union[str, pathlib.Path], options: Optional[Union[dict, Value, DataObject]] = None):
+    def save(self, output_file: PathLike, options: Optional[Union[dict, Value, DataObject]] = None):
         output_file = str(output_file)
-        _err = Error()
+        error = Error()
         options_value = _get_arg_object(options)
         factorylib.lib.psrd_table_save(self._hdr, _c_str(output_file),
                                        _bytes(output_file),
                                        options_value.handler(),
-                                       _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                       error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
     def to_pandas(self) -> "pandas.DataFrame":
         df_builder = _DataFrameBuilder()
@@ -2264,36 +2489,58 @@ class DataFrame(_BaseObject):
         return df_builder.build_polars_dataframe(use_object_dtype=False)
 
 
-    def get(self, expression: str) -> Union[int, float, dt.datetime, str, "DataObject", list, None]:
+    def get(self, expression: str) -> ValueLike:
         value = Value()
-        _err = Error()
+        error = Error()
         factorylib.lib.psrd_table_get_property(self._hdr,
                                                _c_str(expression),
                                                value.handler(),
-                                               _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                               error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
         return value.get()
 
-    def set(self, expression: str, value):
-        _err = Error()
-        _val = Value()
-        _val.set(value)
+    def set(self, expression: str, value: ValueLike):
+        error = Error()
+        value_object = Value()
+        value_object.set(value)
         factorylib.lib.psrd_table_set_property(self._hdr, _c_str(expression),
                                                _bytes(expression),
-                                               _val.handler(),
-                                               _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
+                                               value_object.handler(),
+                                               error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+
+    def as_dict(self) -> Dict[str, ValueLike]:
+        value_dict = ValueDict()
+        error = Error()
+        handler = factorylib.lib.psrd_table_get_as_dict(self._hdr,
+                                                        error.handler())
+        if error.code != 0 or handler is None:
+            raise FactoryException(error.what)
+        value_dict._hdr = handler
+        return value_dict.to_dict()
+
+    def from_dict(self, input_dict: Dict[str, any]):
+        value_dict = ValueDict.from_dict(input_dict)
+        error = Error()
+        factorylib.lib.psrd_table_set_from_dict(self._hdr, value_dict.handler(),
+                                                error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
 
 
-def load_dataframe(input_file: Union[str, pathlib.Path], **kwargs) -> DataFrame:
+def load_dataframe(input_file: PathLike, **kwargs) -> DataFrame:
     options = kwargs.get("options", None)
     return DataFrame.load_from_file(input_file, options)
 
 
-def create_dataframe(data: "pandas.DataFrame", **kwargs) -> DataFrame:
-    return DataFrame.from_dataframe(data, **kwargs)
+def create_dataframe(data: Union[DataFrameLike, dict]) -> DataFrame:
+    if isinstance(data, dict):
+        df = DataFrame()
+        df.from_dict(data)
+        return df
+    return DataFrame.from_dataframe(data)
 
 
 def _load_library():
@@ -2305,13 +2552,12 @@ def _load_library():
     return _loaded
 
 
-
-def _initialize():
-    global _initialized
-    global _initialized_lock
-    with _initialized_lock:
+def _initialize_basic_data():
+    global _basic_data_initialized
+    global _basic_data_initialized_lock
+    with _basic_data_initialized_lock:
         _check_loaded()
-        _err = Error()
+        error = Error()
 
         # Set binding info
         map_prop_values = {
@@ -2325,44 +2571,66 @@ def _initialize():
             "BASE_PREFIX": f"{sys.base_prefix}",
             "REAL_PREFIX": f"{sys.prefix}",
         }
-        for prop, value in map_prop_values.items():
-            _value = Value()
-            _value.set(value)
+        for prop, prop_value in map_prop_values.items():
+            value_object = Value()
+            value_object.set(prop_value)
             factorylib.lib.psrd_set_binding_property(_c_str(prop),
                                                      _bytes(prop),
-                                                     _value.handler(),
-                                                     _err.handler())
-            if _err.code != 0:
-                raise FactoryException(_err.what)
+                                                     value_object.handler(),
+                                                     error.handler())
+            if error.code != 0:
+                raise FactoryException(error.what)
+
+        factorylib.lib.psrd_initialize_basic_data(error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        _basic_data_initialized = True
+
+    _initialize_constants()
+
+
+def _initialize_study_data():
+    global _study_data_initialized
+    global _study_data_initialized_lock
+    with _study_data_initialized_lock:
+        _check_loaded()
+        error = Error()
 
         # Where to look for pmd and pmk files
         module_path = os.path.dirname(__file__)
-        factorylib.lib.psrd_initialize(_c_str(module_path),
-                                       _bytes(module_path),
-                                       _err.handler())
-        if _err.code != 0:
-            raise FactoryException(_err.what)
-        _initialized = True
+        factorylib.lib.psrd_initialize_study_data(_c_str(module_path), _bytes(module_path), error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        _study_data_initialized = True
 
 
+def _initialize_constants():
+    global _constants_initialized
+    global _constants_initialized_lock
+    with _constants_initialized_lock:
+        global _date_transform
+        _check_basic_data_initialized()
+        _date_transform = int(get_constant("DATE_TRANSFORM"))
+        _constants_initialized = True
+
 def _unload():
-    _err = Error()
-    factorylib.lib.psrd_unload(_err.handler())
-    if _err.code != 0:
-        raise FactoryException(_err.what)
+    error = Error()
+    factorylib.lib.psrd_unload(error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
 
 
 def help(context: str = "") -> str:
-    _err = Error()
+    error = Error()
     size = factorylib.lib.psrd_help(_c_str(context), _bytes(context),
-                                    None, 0, _err.handler())
-    if _err.code != 0:
-        raise FactoryException(_err.what)
+                                    None, 0, error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
     buffer = ctypes.create_string_buffer(size)
     factorylib.lib.psrd_help(_c_str(context), _bytes(context),
-                             buffer, size, _err.handler())
-    if _err.code != 0:
-        raise FactoryException(_err.what)
+                             buffer, size, error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
     return _from_c_str(buffer.value)
 
 
@@ -2370,52 +2638,75 @@ def create_study(*args, **kwargs) -> Study:
     blocks = kwargs.get("blocks", None)
     models = kwargs.get("models", None)
     context = kwargs.get("context", None) if len(args) == 0 else args[0]
-    profile = kwargs.get("profile", None)
-    if models is None and profile is not None and len(profile) > 0:
-        models = [profile, ]
-    profile_or_context = models if models is not None and len(models) > 0 \
-        else context
-    return Study.create_object(profile_or_context, blocks)
+    if "profile" in kwargs:
+        raise DeprecationWarning("The 'profile' argument is deprecated. Use 'models' instead.")
+    model_or_context = models if models is not None and len(models) > 0 else context
+    return Study.create_object(model_or_context, blocks)
 
 
-def load_study(study_path: Union[str, pathlib.Path],
-               profile_or_context: Union[str, Context, None] = None,
+def load_study(study_path: PathLike,
+               model_or_context: Union[str, Context, None] = None,
                options: Optional[DataObject] = None) -> Study:
     settings_only = False
-    return Study.load(study_path, profile_or_context, settings_only, options)
+    return Study.load(study_path, model_or_context, settings_only, options)
 
 
-def load_study_settings(study_path: Union[str, pathlib.Path],
-               profile_or_context: Union[str, Context, None] = None,
+def load_study_settings(study_path: PathLike,
+               model_or_context: Union[str, Context, None] = None,
                options: Optional[DataObject] = None) -> Study:
     settings_only = True
-    return Study.load(study_path, profile_or_context, settings_only, options)
-
-
-def create(class_name: str,
-           profile_or_context: Union[str, Context, None] = None) -> Optional[DataObject]:
-    _check_initialized()
-    obj = DataObject()
-    _err = Error()
-    context = _get_context(profile_or_context, None) \
-        if class_name != "Context" else None
-    context_hdr = context.handler() if context is not None else None
-    ref = factorylib.lib.psrd_create(_c_str(class_name),
-                                     context_hdr,
-                                     _err.handler())
-    if _err.code != 0 or ref is None:
-        raise FactoryException(_err.what)
-    obj._hdr = ref
-    return obj
+    return Study.load(study_path, model_or_context, settings_only, options)
+
+
+def create(type_name: str, model_or_context: Union[str, Context, None] = None) -> DataObject:
+    _check_basic_data_initialized()
+    if type_name not in _TYPES_WITHOUT_CONTEXT:
+        _check_study_data_initialized()
+        error = Error()
+        data_object = DataObject()
+        context = _get_context(model_or_context, None)
+        context_handler = context.handler() if context is not None else None
+        handler = factorylib.lib.psrd_create(_c_str(type_name),
+                                             context_handler,
+                                             error.handler())
+    else:
+        error = Error()
+        data_object = DataObject()
+        context_handler = None
+        handler = factorylib.lib.psrd_create(_c_str(type_name),
+                                             context_handler,
+                                             error.handler())
+    if error.code != 0 or handler is None:
+        raise FactoryException(error.what)
+    data_object._hdr = handler
+    return data_object
+
+
+
+def convert_output(input_path: PathLike, output_path: PathLike, **kwargs):
+    _check_basic_data_initialized()
+    options: Optional[Union[dict, Value, DataObject]] = kwargs.get("options", None)
+    input_path = str(input_path)
+    output_path = str(output_path)
+    error = Error()
+    options_value = _get_arg_object(options)
+    factorylib.lib.psrd_convert_output(_c_str(input_path),
+                                      _bytes(input_path),
+                                      _c_str(output_path),
+                                      _bytes(output_path),
+                                      options_value.handler(),
+                                      error.handler())
+    if error.code != 0:
+        raise FactoryException(error.what)
 
 
 def get_default_context() -> "Context":
-    _check_initialized()
+    _check_basic_data_initialized()
     return Context.default_context()
 
 
 def get_new_context() -> "Context":
-    _check_initialized()
+    _check_basic_data_initialized()
     return Context.create()