meerschaum 2.9.5__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

meerschaum/core/Pipe/_attributes.py

@@ -8,11 +8,12 @@ Fetch and manipulate Pipes' attributes
 
 from __future__ import annotations
 
+import uuid
 from datetime import timezone
 
 import meerschaum as mrsm
 from meerschaum.utils.typing import Tuple, Dict, Any, Union, Optional, List
-from meerschaum.utils.warnings import warn
+from meerschaum.utils.warnings import warn, dprint
 
 
 @property
@@ -48,21 +49,89 @@ def attributes(self) -> Dict[str, Any]:
     return self._attributes
 
 
+def get_parameters(
+    self,
+    apply_symlinks: bool = True,
+    refresh: bool = False,
+    debug: bool = False,
+    _visited: 'Optional[set[mrsm.Pipe]]' = None,
+) -> Dict[str, Any]:
+    """
+    Return the `parameters` dictionary of the pipe.
+
+    Parameters
+    ----------
+    apply_symlinks: bool, default True
+        If `True`, resolve references to parameters from other pipes.
+
+    refresh: bool, default False
+        If `True`, pull the latest attributes for the pipe.
+
+    Returns
+    -------
+    The pipe's parameters dictionary.
+    """
+    from meerschaum.config._patch import apply_patch_to_config
+    from meerschaum.config._read_config import search_and_substitute_config
+
+    if _visited is None:
+        _visited = {self}
+
+    if refresh:
+        self._invalidate_cache(hard=True)
+
+    raw_parameters = self.attributes.get('parameters', {})
+    ref_keys = raw_parameters.get('reference')
+    if not apply_symlinks:
+        return raw_parameters
+
+    if ref_keys:
+        try:
+            if debug:
+                dprint(f"Building reference pipe from keys: {ref_keys}")
+            ref_pipe = mrsm.Pipe(**ref_keys)
+            if ref_pipe in _visited:
+                warn(f"Circular reference detected in {self}: chain involves {ref_pipe}.")
+                return search_and_substitute_config(raw_parameters)
+
+            _visited.add(ref_pipe)
+            base_params = ref_pipe.get_parameters(_visited=_visited, debug=debug)
+        except Exception as e:
+            warn(f"Failed to resolve reference pipe for {self}: {e}")
+            base_params = {}
+
+        params_to_apply = {k: v for k, v in raw_parameters.items() if k != 'reference'}
+        parameters = apply_patch_to_config(base_params, params_to_apply)
+    else:
+        parameters = raw_parameters
+
+    from meerschaum.utils.pipes import replace_pipes_syntax
+    self._symlinks = {}
+
+    def recursive_replace(obj: Any, path: tuple) -> Any:
+        if isinstance(obj, dict):
+            return {k: recursive_replace(v, path + (k,)) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [recursive_replace(elem, path + (i,)) for i, elem in enumerate(obj)]
+        if isinstance(obj, str):
+            substituted_val = replace_pipes_syntax(obj)
+            if substituted_val != obj:
+                self._symlinks[path] = {
+                    'original': obj,
+                    'substituted': substituted_val,
+                }
+            return substituted_val
+        return obj
+
+    return search_and_substitute_config(recursive_replace(parameters, tuple()))
+
+
 @property
 def parameters(self) -> Optional[Dict[str, Any]]:
     """
     Return the parameters dictionary of the pipe.
     """
-    if 'parameters' not in self.attributes:
-        self.attributes['parameters'] = {}
-    _parameters = self.attributes['parameters']
-    dt_col = _parameters.get('columns', {}).get('datetime', None)
-    dt_typ = _parameters.get('dtypes', {}).get(dt_col, None) if dt_col else None
-    if dt_col and not dt_typ:
-        if 'dtypes' not in _parameters:
-            self.attributes['parameters']['dtypes'] = {}
-        self.attributes['parameters']['dtypes'][dt_col] = 'datetime'
-    return self.attributes['parameters']
+    return self.get_parameters()
 
 
 @parameters.setter
@@ -71,7 +140,9 @@ def parameters(self, parameters: Dict[str, Any]) -> None:
     Set the parameters dictionary of the in-memory pipe.
     Call `meerschaum.Pipe.edit()` to persist changes.
     """
-    self.attributes['parameters'] = parameters
+    self._attributes['parameters'] = parameters
+    if '_parameters' in self.__dict__:
+        del self.__dict__['_parameters']
 
 
 @property
@@ -79,12 +150,9 @@ def columns(self) -> Union[Dict[str, str], None]:
     """
     Return the `columns` dictionary defined in `meerschaum.Pipe.parameters`.
     """
-    if 'columns' not in self.parameters:
-        self.parameters['columns'] = {}
-    cols = self.parameters['columns']
+    cols = self.parameters.get('columns', {})
     if not isinstance(cols, dict):
-        cols = {}
-        self.parameters['columns'] = cols
+        return {}
     return {col_ix: col for col_ix, col in cols.items() if col}
 
 
@@ -99,7 +167,7 @@ def columns(self, _columns: Union[Dict[str, str], List[str]]) -> None:
     if not isinstance(_columns, dict):
         warn(f"{self}.columns must be a dictionary, received {type(_columns)}.")
         return
-    self.parameters['columns'] = _columns
+    self.update_parameters({'columns': _columns}, persist=False)
 
 
 @property
@@ -112,14 +180,12 @@ def indices(self) -> Union[Dict[str, Union[str, List[str]]], None]:
         if 'indexes' in self.parameters
         else 'indices'
     )
-    if indices_key not in self.parameters:
-        self.parameters[indices_key] = {}
-    _indices = self.parameters[indices_key]
+
+    _indices = self.parameters.get(indices_key, {})
     _columns = self.columns
     dt_col = _columns.get('datetime', None)
     if not isinstance(_indices, dict):
         _indices = {}
-        self.parameters[indices_key] = _indices
     unique_cols = list(set((
         [dt_col]
         if dt_col
@@ -158,7 +224,7 @@ def indices(self, _indices: Union[Dict[str, Union[str, List[str]]], List[str]])
         if 'indexes' in self.parameters
         else 'indices'
     )
-    self.parameters[indices_key] = _indices
+    self.update_parameters({indices_key: _indices}, persist=False)
 
 
 @indexes.setter
@@ -174,41 +240,30 @@ def tags(self) -> Union[List[str], None]:
     """
     If defined, return the `tags` list defined in `meerschaum.Pipe.parameters`.
     """
-    if 'tags' not in self.parameters:
-        self.parameters['tags'] = []
-    return self.parameters['tags']
+    return self.parameters.get('tags', [])
 
 
 @tags.setter
-def tags(self, _tags: List[str, str]) -> None:
+def tags(self, _tags: List[str]) -> None:
     """
     Override the tags list of the in-memory pipe.
     Call `meerschaum.Pipe.edit` to persist changes.
     """
     from meerschaum.utils.warnings import error
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     negation_prefix = STATIC_CONFIG['system']['fetch_pipes_keys']['negation_prefix']
     for t in _tags:
         if t.startswith(negation_prefix):
             error(f"Tags cannot begin with '{negation_prefix}'.")
-    self.parameters['tags'] = _tags
+    self.update_parameters({'tags': _tags}, persist=False)
 
 
 @property
-def dtypes(self) -> Union[Dict[str, Any], None]:
+def dtypes(self) -> Dict[str, Any]:
     """
     If defined, return the `dtypes` dictionary defined in `meerschaum.Pipe.parameters`.
     """
-    from meerschaum.config._patch import apply_patch_to_config
-    from meerschaum.utils.dtypes import MRSM_ALIAS_DTYPES
-    configured_dtypes = self.parameters.get('dtypes', {})
-    remote_dtypes = self.infer_dtypes(persist=False)
-    patched_dtypes = apply_patch_to_config(remote_dtypes, configured_dtypes)
-    return {
-        col: MRSM_ALIAS_DTYPES.get(typ, typ)
-        for col, typ in patched_dtypes.items()
-        if col and typ
-    }
+    return self.get_dtypes(refresh=False)
 
 
 @dtypes.setter
@@ -217,7 +272,60 @@ def dtypes(self, _dtypes: Dict[str, Any]) -> None:
     Override the dtypes dictionary of the in-memory pipe.
     Call `meerschaum.Pipe.edit()` to persist changes.
     """
-    self.parameters['dtypes'] = _dtypes
+    self.update_parameters({'dtypes': _dtypes}, persist=False)
+    _ = self.__dict__.pop('_remote_dtypes', None)
+    _ = self.__dict__.pop('_remote_dtypes_timestamp', None)
+
+
+def get_dtypes(
+    self,
+    infer: bool = True,
+    refresh: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    If defined, return the `dtypes` dictionary defined in `meerschaum.Pipe.parameters`.
+
+
+    Parameters
+    ----------
+    infer: bool, default True
+        If `True`, include the implicit existing dtypes.
+        Else only return the explicitly configured dtypes (e.g. `Pipe.parameters['dtypes']`).
+
+    refresh: bool, default False
+        If `True`, invalidate any cache and return the latest known dtypes.
+
+    Returns
+    -------
+    A dictionary mapping column names to dtypes.
+    """
+    import time
+    from meerschaum.config._patch import apply_patch_to_config
+    from meerschaum.utils.dtypes import MRSM_ALIAS_DTYPES
+    from meerschaum._internal.static import STATIC_CONFIG
+    parameters = self.get_parameters(refresh=refresh, debug=debug)
+    configured_dtypes = parameters.get('dtypes', {})
+    if debug:
+        dprint(f"Configured dtypes for {self}:")
+        mrsm.pprint(configured_dtypes)
+
+    remote_dtypes = self.infer_dtypes(persist=False, refresh=refresh, debug=debug)
+    patched_dtypes = apply_patch_to_config((remote_dtypes or {}), (configured_dtypes or {}))
+
+    dt_col = parameters.get('columns', {}).get('datetime', None)
+    primary_col = parameters.get('columns', {}).get('primary', None)
+    _dtypes = {
+        col: MRSM_ALIAS_DTYPES.get(typ, typ)
+        for col, typ in patched_dtypes.items()
+        if col and typ
+    }
+    if dt_col and dt_col not in configured_dtypes:
+        _dtypes[dt_col] = 'datetime'
+    if primary_col and parameters.get('autoincrement', False) and primary_col not in _dtypes:
+        _dtypes[primary_col] = 'int'
+
+    return _dtypes
 
 
 @property
@@ -225,9 +333,7 @@ def upsert(self) -> bool:
     """
     Return whether `upsert` is set for the pipe.
     """
-    if 'upsert' not in self.parameters:
-        self.parameters['upsert'] = False
-    return self.parameters['upsert']
+    return self.parameters.get('upsert', False)
 
 
 @upsert.setter
@@ -235,7 +341,7 @@ def upsert(self, _upsert: bool) -> None:
     """
     Set the `upsert` parameter for the pipe.
     """
-    self.parameters['upsert'] = _upsert
+    self.update_parameters({'upsert': _upsert}, persist=False)
 
 
 @property
@@ -243,9 +349,7 @@ def static(self) -> bool:
     """
     Return whether `static` is set for the pipe.
     """
-    if 'static' not in self.parameters:
-        self.parameters['static'] = False
-    return self.parameters['static']
+    return self.parameters.get('static', False)
 
 
 @static.setter
@@ -253,7 +357,7 @@ def static(self, _static: bool) -> None:
     """
     Set the `static` parameter for the pipe.
     """
-    self.parameters['static'] = _static
+    self.update_parameters({'static': _static}, persist=False)
 
 
 @property
@@ -261,10 +365,7 @@ def autoincrement(self) -> bool:
     """
     Return the `autoincrement` parameter for the pipe.
     """
-    if 'autoincrement' not in self.parameters:
-        self.parameters['autoincrement'] = False
-
-    return self.parameters['autoincrement']
+    return self.parameters.get('autoincrement', False)
 
 
 @autoincrement.setter
@@ -272,7 +373,23 @@ def autoincrement(self, _autoincrement: bool) -> None:
     """
     Set the `autoincrement` parameter for the pipe.
     """
-    self.parameters['autoincrement'] = _autoincrement
+    self.update_parameters({'autoincrement': _autoincrement}, persist=False)
+
+
+@property
+def autotime(self) -> bool:
+    """
+    Return the `autotime` parameter for the pipe.
+    """
+    return self.parameters.get('autotime', False)
+
+
+@autotime.setter
+def autotime(self, _autotime: bool) -> None:
+    """
+    Set the `autotime` parameter for the pipe.
+    """
+    self.update_parameters({'autotime': _autotime}, persist=False)
 
 
 @property
@@ -280,18 +397,22 @@ def tzinfo(self) -> Union[None, timezone]:
     """
     Return `timezone.utc` if the pipe is timezone-aware.
     """
-    dt_col = self.columns.get('datetime', None)
-    if not dt_col:
-        return None
+    if '_tzinfo' in self.__dict__:
+        return self.__dict__['_tzinfo']
 
-    dt_typ = str(self.dtypes.get(dt_col, 'datetime64[ns, UTC]'))
-    if 'utc' in dt_typ.lower() or dt_typ == 'datetime':
-        return timezone.utc
+    _tzinfo = None
+    dt_col = self.columns.get('datetime', None)
+    dt_typ = str(self.dtypes.get(dt_col, 'datetime')) if dt_col else None
+    if self.autotime:
+        ts_col = mrsm.get_config('pipes', 'autotime', 'column_name_if_datetime_missing')
+        ts_typ = self.dtypes.get(ts_col, 'datetime')
+        dt_typ = ts_typ
 
-    if dt_typ == 'datetime64[ns]':
-        return None
+    if dt_typ and 'utc' in dt_typ.lower() or dt_typ == 'datetime':
+        _tzinfo = timezone.utc
 
-    return None
+    self._tzinfo = _tzinfo
+    return _tzinfo
 
 
 @property
@@ -299,10 +420,7 @@ def enforce(self) -> bool:
     """
     Return the `enforce` parameter for the pipe.
     """
-    if 'enforce' not in self.parameters:
-        self.parameters['enforce'] = True
-
-    return self.parameters['enforce']
+    return self.parameters.get('enforce', True)
 
 
 @enforce.setter
@@ -310,7 +428,7 @@ def enforce(self, _enforce: bool) -> None:
     """
     Set the `enforce` parameter for the pipe.
     """
-    self.parameters['enforce'] = _enforce
+    self.update_parameters({'enforce': _enforce}, persist=False)
 
 
 @property
@@ -318,10 +436,7 @@ def null_indices(self) -> bool:
     """
     Return the `null_indices` parameter for the pipe.
     """
-    if 'null_indices' not in self.parameters:
-        self.parameters['null_indices'] = True
-
-    return self.parameters['null_indices']
+    return self.parameters.get('null_indices', True)
 
 
 @null_indices.setter
@@ -329,7 +444,23 @@ def null_indices(self, _null_indices: bool) -> None:
     """
     Set the `null_indices` parameter for the pipe.
     """
-    self.parameters['null_indices'] = _null_indices
+    self.update_parameters({'null_indices': _null_indices}, persist=False)
+
+
+@property
+def mixed_numerics(self) -> bool:
+    """
+    Return the `mixed_numerics` parameter for the pipe.
+    """
+    return self.parameters.get('mixed_numerics', True)
+
+
+@mixed_numerics.setter
+def mixed_numerics(self, _mixed_numerics: bool) -> None:
+    """
+    Set the `mixed_numerics` parameter for the pipe.
+    """
+    self.update_parameters({'mixed_numerics': _mixed_numerics}, persist=False)
 
 
 def get_columns(self, *args: str, error: bool = False) -> Union[str, Tuple[str]]:
@@ -357,7 +488,7 @@ def get_columns(self, *args: str, error: bool = False) -> Union[str, Tuple[str]]
     >>> pipe.get_columns('value', error=True)
     Exception:  🛑 Missing 'value' column for Pipe('test', 'test').
     """
-    from meerschaum.utils.warnings import error as _error, warn
+    from meerschaum.utils.warnings import error as _error
     if not args:
         args = tuple(self.columns.keys())
     col_names = []
@@ -367,7 +498,7 @@ def get_columns(self, *args: str, error: bool = False) -> Union[str, Tuple[str]]
             col_name = self.columns[col]
             if col_name is None and error:
                 _error(f"Please define the name of the '{col}' column for {self}.")
-        except Exception as e:
+        except Exception:
             col_name = None
         if col_name is None and error:
             _error(f"Missing '{col}'" + f" column for {self}.")
@@ -409,16 +540,18 @@ def get_columns_types(
     """
     import time
     from meerschaum.connectors import get_connector_plugin
-    from meerschaum.config.static import STATIC_CONFIG
-    from meerschaum.utils.warnings import dprint
+    from meerschaum._internal.static import STATIC_CONFIG
 
     now = time.perf_counter()
-    cache_seconds = STATIC_CONFIG['pipes']['static_schema_cache_seconds']
-    if not self.static:
-        refresh = True
+    cache_seconds = (
+        mrsm.get_config('pipes', 'static', 'static_schema_cache_seconds')
+        if self.static
+        else mrsm.get_config('pipes', 'dtypes', 'columns_types_cache_seconds')
+    )
     if refresh:
         _ = self.__dict__.pop('_columns_types_timestamp', None)
         _ = self.__dict__.pop('_columns_types', None)
+
     _columns_types = self.__dict__.get('_columns_types', None)
     if _columns_types:
         columns_types_timestamp = self.__dict__.get('_columns_types_timestamp', None)
@@ -454,14 +587,13 @@ def get_columns_indices(
     """
     import time
     from meerschaum.connectors import get_connector_plugin
-    from meerschaum.config.static import STATIC_CONFIG
-    from meerschaum.utils.warnings import dprint
+    from meerschaum._internal.static import STATIC_CONFIG
 
     now = time.perf_counter()
     cache_seconds = (
-        STATIC_CONFIG['pipes']['static_schema_cache_seconds']
+        mrsm.get_config('pipes', 'static', 'static_schema_cache_seconds')
         if self.static
-        else STATIC_CONFIG['pipes']['exists_timeout_seconds']
+        else mrsm.get_config('pipes', 'dtypes', 'columns_types_cache_seconds')
     )
     if refresh:
         _ = self.__dict__.pop('_columns_indices_timestamp', None)
@@ -509,7 +641,7 @@ def get_id(self, **kw: Any) -> Union[int, None]:
 
 
 @property
-def id(self) -> Union[int, None]:
+def id(self) -> Union[int, str, uuid.UUID, None]:
     """
     Fetch and cache a pipe's ID.
     """
@@ -534,12 +666,11 @@ def get_val_column(self, debug: bool = False) -> Union[str, None]:
     -------
     Either a string or `None`.
     """
-    from meerschaum.utils.debug import dprint
     if debug:
         dprint('Attempting to determine the value column...')
     try:
         val_name = self.get_columns('value')
-    except Exception as e:
+    except Exception:
         val_name = None
     if val_name is not None:
         if debug:
@@ -553,11 +684,11 @@ def get_val_column(self, debug: bool = False) -> Union[str, None]:
         return None
     try:
         dt_name = self.get_columns('datetime', error=False)
-    except Exception as e:
+    except Exception:
         dt_name = None
     try:
         id_name = self.get_columns('id', errors=False)
-    except Exception as e:
+    except Exception:
         id_name = None
 
     if debug:
@@ -596,6 +727,7 @@ def parents(self) -> List[mrsm.Pipe]:
     """
     if 'parents' not in self.parameters:
         return []
+
     from meerschaum.utils.warnings import warn
     _parents_keys = self.parameters['parents']
     if not isinstance(_parents_keys, list):
@@ -634,6 +766,7 @@ def children(self) -> List[mrsm.Pipe]:
     """
     if 'children' not in self.parameters:
         return []
+
     from meerschaum.utils.warnings import warn
     _children_keys = self.parameters['children']
     if not isinstance(_children_keys, list):
@@ -714,7 +847,7 @@ def target(self, _target: str) -> None:
     Override the target of the in-memory pipe.
     Call `meerschaum.Pipe.edit` to persist changes.
     """
-    self.parameters['target'] = _target
+    self.update_parameters({'target': _target}, persist=False)
 
 
 def guess_datetime(self) -> Union[str, None]:
@@ -755,3 +888,192 @@ def get_indices(self) -> Dict[str, str]:
             result = {}
     
     return result
+
+
+def update_parameters(
+    self,
+    parameters_patch: Dict[str, Any],
+    persist: bool = True,
+    debug: bool = False,
+) -> mrsm.SuccessTuple:
+    """
+    Apply a patch to a pipe's `parameters` dictionary.
+
+    Parameters
+    ----------
+    parameters_patch: Dict[str, Any]
+        The patch to be applied to `Pipe.parameters`.
+
+    persist: bool, default True
+        If `True`, call `Pipe.edit()` to persist the new parameters.
+    """
+    from meerschaum.config import apply_patch_to_config
+    if 'parameters' not in self._attributes:
+        self._attributes['parameters'] = {}
+
+    if '_parameters' not in self.__dict__:
+        self._parameters = {}
+
+    self._attributes['parameters'] = apply_patch_to_config(
+        self._attributes['parameters'],
+        parameters_patch,
+    )
+
+    if self.temporary:
+        persist = False
+
+    if not persist:
+        return True, "Success"
+
+    return self.edit(debug=debug)
+
+
+def get_precision(self, debug: bool = False) -> Dict[str, Union[str, int]]:
+    """
+    Return the timestamp precision unit and interval for the `datetime` axis.
+    """
+    from meerschaum.utils.dtypes import (
+        MRSM_PRECISION_UNITS_SCALARS,
+        MRSM_PRECISION_UNITS_ALIASES,
+        MRSM_PD_DTYPES,
+        are_dtypes_equal,
+    )
+    from meerschaum._internal.static import STATIC_CONFIG
+
+    if self.__dict__.get('_precision', None):
+        if debug:
+            dprint(f"Returning cached precision: {self._precision}")
+        return self._precision
+
+    parameters = self.parameters
+    _precision = parameters.get('precision', {})
+    if isinstance(_precision, str):
+        _precision = {'unit': _precision}
+    default_precision_unit = STATIC_CONFIG['dtypes']['datetime']['default_precision_unit']
+
+    if not _precision:
+
+        dt_col = parameters.get('columns', {}).get('datetime', None)
+        if not dt_col and self.autotime:
+            dt_col = mrsm.get_config('pipes', 'autotime', 'column_name_if_datetime_missing')
+        if not dt_col:
+            if debug:
+                dprint(f"No datetime axis, returning default precision '{default_precision_unit}'.")
+            return {'unit': default_precision_unit}
+
+        dt_typ = self.dtypes.get(dt_col, 'datetime')
+        if are_dtypes_equal(dt_typ, 'datetime'):
+            if dt_typ == 'datetime':
+                dt_typ = MRSM_PD_DTYPES['datetime']
+                if debug:
+                    dprint(f"Datetime type is `datetime`, assuming {dt_typ} precision.")
+
+            _precision = {
+                'unit': (
+                    dt_typ
+                    .split('[', maxsplit=1)[-1]
+                    .split(',', maxsplit=1)[0]
+                    .split(' ', maxsplit=1)[0]
+                ).rstrip(']')
+            }
+
+            if debug:
+                dprint(f"Extracted precision '{_precision['unit']}' from type '{dt_typ}'.")
+
+        elif are_dtypes_equal(dt_typ, 'int'):
+            _precision = {
+                'unit': (
+                    'second'
+                    if '32' in dt_typ
+                    else default_precision_unit
+                )
+            }
+        elif are_dtypes_equal(dt_typ, 'date'):
+            if debug:
+                dprint("Datetime axis is 'date', falling back to 'day' precision.")
+            _precision = {'unit': 'day'}
+
+    precision_unit = _precision.get('unit', default_precision_unit)
+    precision_interval = _precision.get('interval', None)
+    true_precision_unit = MRSM_PRECISION_UNITS_ALIASES.get(precision_unit, precision_unit)
+    if true_precision_unit is None:
+        if debug:
+            dprint(f"No precision could be determined, falling back to '{default_precision_unit}'.")
+        true_precision_unit = default_precision_unit
+
+    if true_precision_unit not in MRSM_PRECISION_UNITS_SCALARS:
+        from meerschaum.utils.misc import items_str
+        raise ValueError(
+            f"Invalid precision unit '{true_precision_unit}'.\n"
+            "Accepted values are "
+            f"{items_str(list(MRSM_PRECISION_UNITS_SCALARS) + list(MRSM_PRECISION_UNITS_ALIASES))}."
+        )
+
+    self._precision = {'unit': true_precision_unit}
+    if precision_interval:
+        self._precision['interval'] = precision_interval
+    return self._precision
+
+
+@property
+def precision(self) -> Dict[str, Union[str, int]]:
+    """
+    Return the configured or detected precision.
+    """
+    return self.get_precision()
+
+
+@precision.setter
+def precision(self, _precision: Union[str, Dict[str, Union[str, int]]]) -> None:
+    """
+    Update the `precision` parameter.
+    """
+    existing_precision = self._attributes.get('parameters', {}).get('precision', None)
+    if isinstance(existing_precision, str):
+        existing_precision = {'unit': existing_precision}
+
+    true_precision = (
+        _precision
+        if isinstance(_precision, dict)
+        else {
+            'unit': _precision,
+            **(
+                {
+                    'interval': existing_precision['interval'],
+                } if existing_precision else {}
+            )
+        }
+    )
+
+    self.update_parameters({'precision': true_precision}, persist=False)
+    _ = self.__dict__.pop('_precision', None)
+
+
+def _invalidate_cache(
+    self,
+    hard: bool = False,
+    debug: bool = False,
+) -> None:
+    """
+    Invalidate temporary metadata cache.
+
+    Parameters
+    ----------
+    hard: bool, default False
+        If `True`, clear all temporary cache.
+        Otherwise only clear soft cache.
+    """
+    if debug:
+        dprint(f"Invalidating {'some' if not hard else 'all'} cache for {self}.")
+
+    self._exists = None
+    self._sync_ts = None
+
+    if not hard:
+        return
+
+    _ = self.__dict__.pop('_parameters', None)
+    _ = self.__dict__.pop('_precision', None)
+    self._columns_types_timestamp = None
+    self._columns_types = None
+    self._attributes_sync_time = None