psr-factory 5.0.0b21__py3-none-win_amd64.whl → 5.0.0b69__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,9 +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."""
@@ -88,11 +113,14 @@ 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()
 
-# States whether the library is initialized.
-# It should be to correctly load and build models.
-_initialized = False
-_initialized_lock = threading.Lock()
+_constants_initialized = False
+_constants_initialized_lock = threading.Lock()
 
 _loaded = False
 _loaded_lock = threading.Lock()
@@ -101,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_initialized():
+def _check_basic_data_initialized():
     """Checks if the module was initialized."""
-    global _initialized
-    if not _initialized:
-        _initialize()
-    return _initialized
+    global _basic_data_initialized
+    if not _basic_data_initialized:
+        _initialize_basic_data()
+    return _basic_data_initialized
+
+def _check_study_data_initialized():
+    """Checks if the module was initialized."""
+    global _study_data_initialized
+    if not _study_data_initialized:
+        _initialize_study_data()
+    return _study_data_initialized
 
 
 def _check_loaded() -> bool:
@@ -192,7 +226,7 @@ def version() -> str:
     return _version_long()
 
 
-def build_version() -> str:
+def short_version() -> str:
     """Returns short library version."""
     return _version_short()
 
@@ -258,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" \
@@ -279,41 +315,48 @@ 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],
@@ -478,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()
@@ -493,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()
@@ -526,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,
@@ -550,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,
@@ -575,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,
@@ -649,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,
@@ -667,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,
@@ -706,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:
@@ -748,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,
@@ -756,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,
@@ -820,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):
@@ -835,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)
@@ -855,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())
@@ -872,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()
@@ -924,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,
@@ -934,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),
@@ -967,7 +1034,6 @@ class PropertyDescription(_BaseObject):
             return f"Property {self.name} with dimensions {self.dimensions()}"
 
 
-
 class DataObject(_BaseObject):
     def __init__(self):
         super().__init__()
@@ -1009,16 +1075,16 @@ class DataObject(_BaseObject):
         dest._hdr = ref
         return dest
 
-    def __deepcopy__(self, memodict=None):
+    def __deepcopy__(self, memo_dict=None):
         raise NotImplementedError()
 
     def __repr__(self):
         identifiers = []
-        if self.code != 0:
+        if self.has_code():
             identifiers.append(f"code={self.code}")
-        if self.id != "":
+        if self.has_id():
             identifiers.append(f"id={self.id.strip()}")
-        if self.name != "":
+        if self.has_name():
             identifiers.append(f"name={self.name.strip()}")
         return f"psr.factory.DataObject({self.type}, {', '.join(identifiers)})"
 
@@ -1030,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,
@@ -1040,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,
@@ -1061,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,
@@ -1072,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()
@@ -1088,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,
@@ -1106,7 +1196,7 @@ class DataObject(_BaseObject):
         if error.code != 0:
             raise FactoryException(error.what)
 
-    def get_df(self, expression: str) -> Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]:
+    def get_df(self, expression: str) -> DataFrameLike:
         _err = Error()
         _df = DataFrame()
         factorylib.lib.psrd_object_get_table(self._hdr, _df.handler(),
@@ -1130,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()
@@ -1147,19 +1237,19 @@ class DataObject(_BaseObject):
         if _err.code != 0:
             raise FactoryException(_err.what)
 
-    def set_df(self, dataframe_like):
-        if not _has_pandas():
-            raise ModuleNotFoundError("pandas required.")
-        dataframe_like = pandas.api.interchange.from_dataframe(dataframe_like)
+    def set_df(self, dataframe_like: DataFrameLike):
         df_builder = _DataFrameBuilder()
-        _df = df_builder.build_from_pandas(dataframe_like)
+        if _has_pandas() and isinstance(dataframe_like, pandas.DataFrame):
+            _df = df_builder.build_from_pandas(dataframe_like)
+        elif _has_polars() and isinstance(dataframe_like, polars.DataFrame):
+            _df = df_builder.build_from_polars(dataframe_like)
+        else:
+            raise FactoryException("No supported DataFrame library is available.")
         _err = Error()
-        factorylib.lib.psrd_object_set_table(self._hdr, _df.handler(),
-                                             _err.handler())
+        factorylib.lib.psrd_object_set_table(self._hdr, _df.handler(), _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)
 
-
     def clear_values(self, expression: str):
         _err = Error()
         factorylib.lib.psrd_object_clear_values(self._hdr,
@@ -1191,6 +1281,14 @@ class DataObject(_BaseObject):
         object_list._hdr = ref
         return object_list.to_list()
 
+    def has_code(self) -> bool:
+        _err = Error()
+        bool_value = ctypes.c_bool()
+        factorylib.lib.psrd_object_has_code(self._hdr, ctypes.byref(bool_value), _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(bool_value.value)
+
     @property
     def code(self) -> int:
         _err = Error()
@@ -1236,6 +1334,42 @@ 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")
+
+    def has_name(self) -> bool:
+        _err = Error()
+        bool_value = ctypes.c_bool()
+        factorylib.lib.psrd_object_has_name(self._hdr, ctypes.byref(bool_value), _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(bool_value.value)
+
     @property
     def name(self) -> str:
         err = Error()
@@ -1264,6 +1398,14 @@ class DataObject(_BaseObject):
     def name(self):
         raise AttributeError("do not delete name")
 
+    def has_id(self) -> bool:
+        _err = Error()
+        bool_value = ctypes.c_bool()
+        factorylib.lib.psrd_object_has_id(self._hdr, ctypes.byref(bool_value), _err.handler())
+        if _err.code != 0:
+            raise FactoryException(_err.what)
+        return bool(bool_value.value)
+
     @property
     def id(self) -> str:
         err = Error()
@@ -1296,7 +1438,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())
@@ -1346,7 +1488,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(),
@@ -1357,7 +1499,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)
 
 
@@ -1371,7 +1514,8 @@ class Study(_BaseObject):
     @staticmethod
     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(model_or_context, blocks)
         study = Study()
@@ -1382,12 +1526,13 @@ class Study(_BaseObject):
         return study
 
     @staticmethod
-    def load(study_path: Union[str, pathlib.Path], model_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(model_or_context, None)
         error = Error()
@@ -1404,7 +1549,7 @@ class Study(_BaseObject):
             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)
         error = Error()
@@ -1416,7 +1561,7 @@ class Study(_BaseObject):
         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)
         error = Error()
@@ -1430,7 +1575,8 @@ class Study(_BaseObject):
 
     @property
     def context(self) -> "Context":
-        _check_initialized()
+        _check_basic_data_initialized()
+        _check_study_data_initialized()
         obj = Context()
         error = Error()
         ref = factorylib.lib.psrd_study_context(self._hdr,
@@ -1440,7 +1586,7 @@ class Study(_BaseObject):
         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()
         error = Error()
         factorylib.lib.psrd_study_get_value(self._hdr,
@@ -1451,8 +1597,8 @@ class Study(_BaseObject):
             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()
         error = Error()
@@ -1467,7 +1613,7 @@ class Study(_BaseObject):
             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,
@@ -1515,6 +1661,33 @@ 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)
         error = Error()
@@ -1575,7 +1748,7 @@ class Study(_BaseObject):
         object_list._hdr = ref
         return object_list.to_list()
 
-    def set(self, expression: str, value: any):
+    def set(self, expression: str, value: ValueLike):
         error = Error()
         value_object = Value()
         value_object.set(value)
@@ -1587,7 +1760,7 @@ class Study(_BaseObject):
         if error.code != 0:
             raise FactoryException(error.what)
 
-    def set_at(self, expression: str, range_expr: Union[str, dt.datetime], value: any):
+    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.")
         error = Error()
@@ -1604,7 +1777,7 @@ class Study(_BaseObject):
         if error.code != 0:
             raise FactoryException(error.what)
 
-    def get_df(self, expression: str) -> Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]:
+    def get_df(self, expression: str) -> DataFrameLike:
         error = Error()
         df = DataFrame()
         factorylib.lib.psrd_study_get_table(self._hdr, df.handler(),
@@ -1617,7 +1790,7 @@ class Study(_BaseObject):
         df_builder.build_dataframe(df)
         return df_builder.build_desired_dataframe_type()
 
-    def get_objects_values(self, object_type: str, columns: List[str]) -> Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]:
+    def get_objects_values(self, object_type: str, columns: List[str]) -> DataFrameLike:
         error = Error()
         df = DataFrame()
         columns_list = Value()
@@ -1632,7 +1805,7 @@ class Study(_BaseObject):
         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_value: Union[str, dt.datetime]) -> Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]:
+    def get_objects_values_at(self, object_type: str, columns: List[str], range_value: DateLike) -> DataFrameLike:
         error = Error()
         df = DataFrame()
         range_object = Value()
@@ -1650,7 +1823,7 @@ class Study(_BaseObject):
         df_builder.build_dataframe(df)
         return df_builder.build_desired_dataframe_type()
 
-    def properties(self) -> Dict[str, PropertyDescription]:
+    def descriptions(self) -> Dict[str, PropertyDescription]:
         error = Error()
         value = ctypes.c_long()
         factorylib.lib.psrd_study_property_description_count(self._hdr,
@@ -1671,6 +1844,29 @@ class Study(_BaseObject):
             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.")
@@ -1733,6 +1929,8 @@ def _polars_dtype_to_column_type(dtype: "polars.datatypes.classes.DataTypeClass"
         return 4
     if dtype == polars.String:
         return 5
+    if dtype == polars.Boolean:
+        return 1  # TODO: create a boolean column type
     else:
         raise FactoryException(f"Unsupported polars dtype \"{dtype}\".")
 
@@ -1865,6 +2063,8 @@ class _DataFrameBuilder:
                 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)()
@@ -1895,7 +2095,7 @@ class _DataFrameBuilder:
             self.columns[column].values = array_values
         self._not_built = False
 
-    def build_desired_dataframe_type(self, **kwargs) -> Union["pandas.DataFrame", "polars.DataFrame", "DataFrame"]:
+    def build_desired_dataframe_type(self, **kwargs) -> DataFrameLike:
         if _default_dataframe_type == "pandas":
             return self.build_pandas_dataframe(**kwargs)
         elif _default_dataframe_type == "polars":
@@ -1949,6 +2149,8 @@ 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 = [_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]
@@ -1989,9 +2191,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 = {}
@@ -2024,6 +2226,8 @@ 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
@@ -2133,7 +2337,7 @@ class _DataFrameBuilder:
         return df
 
     def build_polars_dataframe(self, **kwargs) -> "polars.DataFrame":
-        use_object_dtype = kwargs.get("use_object_dtype", True)
+        use_object_dtype = kwargs.get("use_object_dtype", False)
         if not _has_polars():
             raise ModuleNotFoundError("polars required.")
         def convert_column_values(column_name:str, values):
@@ -2147,15 +2351,17 @@ class _DataFrameBuilder:
         data = {column.name: convert_column_values(column.name, column.values)
                 for column in self.indices + self.columns}
         if use_object_dtype:
-            return polars.DataFrame(data=data, dtype=object)
+            return polars.DataFrame({k: polars.Series(k, v, dtype=polars.Object) for k, v in data.items()})
         else:
             return polars.DataFrame(data=data)
 
     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", "date")
         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:
@@ -2256,9 +2462,9 @@ 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()
+        _check_basic_data_initialized()
         error = Error()
         df = DataFrame()
         options_value = _get_arg_object(options)
@@ -2272,8 +2478,8 @@ class DataFrame(_BaseObject):
         return df
 
     @staticmethod
-    def from_dataframe(df: Union["pandas.DataFrame", "polars.DataFrame", "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
@@ -2287,7 +2493,7 @@ 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)
         error = Error()
         options_value = _get_arg_object(options)
@@ -2309,7 +2515,7 @@ 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()
         error = Error()
         factorylib.lib.psrd_table_get_property(self._hdr,
@@ -2320,7 +2526,7 @@ class DataFrame(_BaseObject):
             raise FactoryException(error.what)
         return value.get()
 
-    def set(self, expression: str, value: any):
+    def set(self, expression: str, value: ValueLike):
         error = Error()
         value_object = Value()
         value_object.set(value)
@@ -2331,14 +2537,36 @@ class DataFrame(_BaseObject):
         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: Union["pandas.DataFrame", "polars.DataFrame", "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():
@@ -2350,11 +2578,10 @@ 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()
         error = Error()
 
@@ -2380,15 +2607,37 @@ def _initialize():
             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),
-                                       error.handler())
+        factorylib.lib.psrd_initialize_study_data(_c_str(module_path), _bytes(module_path), error.handler())
         if error.code != 0:
             raise FactoryException(error.what)
-        _initialized = True
+        _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():
     error = Error()
@@ -2421,44 +2670,69 @@ def create_study(*args, **kwargs) -> Study:
     return Study.create_object(model_or_context, blocks)
 
 
-def load_study(study_path: Union[str, pathlib.Path],
+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, model_or_context, settings_only, options)
 
 
-def load_study_settings(study_path: Union[str, pathlib.Path],
+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, model_or_context, settings_only, options)
 
 
-def create(class_name: str,
-           model_or_context: Union[str, Context, None] = None) -> Optional[DataObject]:
-    _check_initialized()
-    data_object = DataObject()
-    error = Error()
-    context = _get_context(model_or_context, None) \
-        if class_name != "Context" else None
-    context_handler = context.handler() if context is not None else None
-    handler = factorylib.lib.psrd_create(_c_str(class_name),
-                                         context_handler,
-                                         error.handler())
+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()