fram-core 0.1.0a1__py3-none-any.whl → 0.1.1__py3-none-any.whl

framcore/expressions/_get_constant_from_expr.py

@@ -164,7 +164,7 @@ def _update_constants_with_units(
         if isinstance(obj, TimeVector):
             obj: TimeVector
 
-            # added to support any_expr * ConstantTimeVector
+            # added to support any_expr * ConstantTimeVector. We added this to support LevelProfile.scale()
             times_constant_case = (not is_profile) and isinstance(obj, ConstantTimeVector)
 
             if is_level or times_constant_case:
@@ -215,16 +215,6 @@ def _is_fastpath_product(expr: Expr) -> bool:
     return all(arg.is_leaf() or _is_fastpath_sum(arg) for arg in args)
 
 
-def _is_fastpath_sum(expr: Expr) -> bool:
-    """x1 + x2 + .. + xn where x is leaf and n >= 1."""
-    if expr.is_leaf():
-        return True
-    ops, args = expr.get_operations(expect_ops=True, copy_list=False)
-    if ops[0] not in "+-":
-        return False
-    return all(arg.is_leaf() for op, arg in zip(ops, args[1:], strict=True))
-
-
 def _is_fastpath_sum_of_products(expr: Expr) -> bool:
     """E.g. x1 * (x2 + x3) + x4 * x5 where x is leaf."""
     if expr.is_leaf():
@@ -344,19 +334,23 @@ def _fastpath_aggregation(  # noqa: C901, PLR0911
             return num_value / dem_value
         return get_unit_conversion_factor(combined_unit, target_unit) * (num_value / dem_value)
 
-    combined_num_unit = ""
-    for unit, value in num.items():
-        op = "+" if value > 0 else "-"
-        combined_num_unit = f"{combined_num_unit} {op} {abs(value)}"
+    new_constants_with_units = dict()
 
-    combined_dem_unit = ""
+    combined_num = ""
     for unit, value in num.items():
-        op = "+" if value > 0 else "-"
-        combined_dem_unit = f"{combined_dem_unit} {op} {abs(value)}"
+        sym = f"x{len(new_constants_with_units)}"
+        new_constants_with_units[sym] = (sym, value, unit)
+        combined_num = f"{combined_num} + {sym}"
+
+    combined_dem = ""
+    for unit, value in dem.items():
+        sym = f"x{len(new_constants_with_units)}"
+        new_constants_with_units[sym] = (sym, value, unit)
+        combined_dem = f"{combined_dem} + {sym}"
 
-    combined_unit = f"({combined_num_unit})/({combined_dem_unit})"
+    combined = f"({combined_num})/({combined_dem})"
 
-    return get_unit_conversion_factor(combined_unit, target_unit)
+    return _sympy_fallback(new_constants_with_units, combined, target_unit)
 
 
 def _get_fastpath_sum_dict(

framcore/expressions/queries.py

@@ -1,18 +1,20 @@
 from __future__ import annotations
 
 import time
+from datetime import timedelta
 from typing import TYPE_CHECKING
 
 import numpy as np
 from numpy.typing import NDArray
 
+from framcore import check_type
 from framcore.curves import Curve
 from framcore.expressions import Expr
 from framcore.expressions._get_constant_from_expr import _get_constant_from_expr
 from framcore.expressions._utils import _load_model_and_create_model_db
 from framcore.expressions.units import get_unit_conversion_factor
 from framcore.querydbs import QueryDB
-from framcore.timeindexes import FixedFrequencyTimeIndex, SinglePeriodTimeIndex, TimeIndex
+from framcore.timeindexes import FixedFrequencyTimeIndex, ProfileTimeIndex, SinglePeriodTimeIndex, TimeIndex, WeeklyIndex
 from framcore.timevectors import TimeVector
 
 if TYPE_CHECKING:
@@ -28,34 +30,26 @@ def get_level_value(
     is_max: bool,
 ) -> float:
     """
-    Evaluate expr representing a (possibly aggregated) level.
+    Evaluate Expr representing a (possibly aggregated) level.
 
-    The follwing will be automatically handeled for you:
-      - conversion to requested unit
-      - conversion to requested reference period
-      - conversion to requested level type
-      - fetching from different data objecs
+    The follwing will be automatically handled for you:
+    - fetching from different data objecs (from db)
+    - conversion to requested unit
+    - query at requested TimeIndex for data and scenario dimension, and with requested reference period
+    - conversion to requested level type (is_max or is_avg)
 
-    expr = sum(scale[i] * level[i]) where
+    Supports all expressions. Will evaluate level Exprs at data_dim (with reference period of scen_dim),
+    and profile Exprs as an average over scen_dim (both as constants). Has optimized fastpath methods for sums, products and aggregations.
+    The rest uses a fallback method with SymPy.
 
-        scale[i] >= 0 and is unitless
-        level[i] is a unitful level expr
-
-        level[i] is either "avg" or "max" type of level
-
-        if "avg", it has a reference period (startyear, startyear + numyears) and a corresponding
-        "mean_one" profile, for which mean(values) = 1 for values covering the reference period
-
-        "avg" and "max" level type must be converted to the same standard to be added correctly.
-
-        Two "avg" types with different reference period must be converted to same reference period
-        to be added correctly.
-
-        The query parameter scen_dim tells which reference period to convert to.
-
-        The query parameter is_max tells which level type to convert to.
     """
+    check_type(expr, Expr)  # check expr here since _get_level_value is not recursively called.
+    check_type(unit, (str, type(None)))
+    check_type(data_dim, SinglePeriodTimeIndex)
+    check_type(scen_dim, FixedFrequencyTimeIndex)
+    check_type(is_max, bool)
     db = _load_model_and_create_model_db(db)
+
     return _get_level_value(expr, db, unit, data_dim, scen_dim, is_max)
 
 
@@ -72,7 +66,7 @@ def get_profile_vector(
 
     expr = sum(weight[i] * profile[i]) where
 
-        weight[i] >= 0 and is unitless
+        weight[i] >= 0 and is unitless, and will be evaluated as a constant
         profile[i] is a unitless profile expr
 
         profile[i] is either "zero_one" or "mean_one" type of profile
@@ -80,15 +74,24 @@ def get_profile_vector(
         "zero_one" and "mean_one" profile type must be converted to the
         same standard to be added correctly.
 
-        The query parameter data_dim is used to compute weight[i].
+        The query parameters data_dim and scen_dim are used to evaluate the values
+        requested TimeIndex for data and scenario dimension, and with requested reference period
 
-        The query parameter scen_dim specifies the out vector dimension.
+        weight[i] will be evaluated level Exprs at data_dim (with reference period of scen_dim),
+        and profile Exprs as an average over scen_dim (both as constants)
+
+        profile[i] will be evaluated as profile vectors over scen_dim
 
         The query parameter is_zero_one tells which profile type the output
         vector should be converted to.
     """
+    # Argument expr checked in _get_profile_vector since it can be recursively called.
+    check_type(data_dim, SinglePeriodTimeIndex)
+    check_type(scen_dim, FixedFrequencyTimeIndex)
+    check_type(is_zero_one, bool)
+    check_type(is_float32, bool)
     db = _load_model_and_create_model_db(db)
-    # TODO: Implement checks cleaner
+
     return _get_profile_vector(expr, db, data_dim, scen_dim, is_zero_one, is_float32)
 
 
@@ -126,9 +129,6 @@ def _get_level_value(
     scen_dim: FixedFrequencyTimeIndex,
     is_max: bool,
 ) -> float:
-    # TODO: Implement checks cleaner
-    assert isinstance(expr, Expr), f"{expr}"
-
     cache_key = ("_get_constant_from_expr", expr, unit, data_dim, scen_dim, is_max)
     if db.has_key(cache_key):
         return db.get(cache_key)
@@ -148,34 +148,12 @@ def _get_profile_vector(
     is_zero_one: bool,
     is_float32: bool = True,
 ) -> NDArray:
-    assert isinstance(expr, Expr), f"{expr}"
+    check_type(expr, Expr)
 
     if expr.is_leaf():
-        src = expr.get_src()
-
-        if isinstance(src, str):
-            obj = db.get(src)
-        else:
-            assert isinstance(src, TimeVector)
-            obj = src
-
-        if isinstance(obj, Expr):
-            assert obj.is_profile(), f"{obj}"
-            return _get_profile_vector(obj, db, data_dim, scen_dim, is_zero_one, is_float32)
-
-        assert isinstance(obj, TimeVector)
-        cache_key = ("_get_profile_vector_from_timevector", obj, data_dim, scen_dim, is_zero_one, is_float32)
-        if db.has_key(cache_key):
-            vector: NDArray = db.get(cache_key)
-            return vector.copy()
-        t0 = time.perf_counter()
-        vector = _get_profile_vector_from_timevector(obj, scen_dim, is_zero_one, is_float32)
-        t1 = time.perf_counter()
-        db.put(cache_key, vector, elapsed_seconds=t1 - t0)
-        return vector
+        return _get_profile_vector_from_leaf_expr(expr, db, data_dim, scen_dim, is_zero_one, is_float32)
 
     ops, args = expr.get_operations(expect_ops=True, copy_list=False)
-
     tmp = np.zeros(scen_dim.get_num_periods(), dtype=np.float32 if is_float32 else np.float64)
 
     if "+" in ops:
@@ -192,18 +170,56 @@ def _get_profile_vector(
 
     profiles = [arg for arg in args if arg.is_profile()]
     weights = [arg for arg in args if not arg.is_profile()]
+
     if len(profiles) != 1:
         message = f"Got {len(profiles)} profiles in expr {expr}"
         raise ValueError(message)
+
     total_weight = 0.0
     is_max = False  # use avg-values to calculate weights
+
     for weight_expr in weights:
         total_weight += _get_constant_from_expr(weight_expr, db, None, data_dim, scen_dim, is_max)
+
     out = _get_profile_vector(profiles[0], db, data_dim, scen_dim, is_zero_one, is_float32)
     np.multiply(out, total_weight, out=out)
     return out
 
 
+def _get_profile_vector_from_leaf_expr(
+    expr: Expr,
+    db: QueryDB,
+    data_dim: SinglePeriodTimeIndex,
+    scen_dim: FixedFrequencyTimeIndex,
+    is_zero_one: bool,
+    is_float32: bool,
+) -> NDArray:
+    src = expr.get_src()
+
+    if isinstance(src, str):
+        obj = db.get(src)
+    else:
+        obj = src
+
+    if isinstance(obj, Expr):
+        if not obj.is_profile():
+            msg = f"Expected {obj} to be is_profile=True."  # User may be getting this from setting wrong metadata in time vector files?
+            raise ValueError(msg)
+        return _get_profile_vector(obj, db, data_dim, scen_dim, is_zero_one, is_float32)
+
+    assert isinstance(obj, (TimeVector, Curve))
+
+    cache_key = ("_get_profile_vector_from_timevector", obj, data_dim, scen_dim, is_zero_one, is_float32)
+    if db.has_key(cache_key):
+        vector: NDArray = db.get(cache_key)
+        return vector.copy()
+    t0 = time.perf_counter()
+    vector = _get_profile_vector_from_timevector(obj, scen_dim, is_zero_one, is_float32)
+    t1 = time.perf_counter()
+    db.put(cache_key, vector, elapsed_seconds=t1 - t0)
+    return vector
+
+
 def _get_profile_vector_from_timevector(
     timevector: TimeVector,
     scen_dim: FixedFrequencyTimeIndex,
@@ -254,7 +270,6 @@ def _get_profile_vector_from_timevector(
 def _recursively_update_units(units: set[str], db: QueryDB, expr: Expr) -> None:
     if expr.is_leaf():
         src = expr.get_src()
-
         obj = src if isinstance(src, TimeVector) else db.get(key=src)
 
         if isinstance(obj, Expr):
@@ -274,27 +289,6 @@ def _recursively_update_units(units: set[str], db: QueryDB, expr: Expr) -> None:
         _recursively_update_units(units, db, arg)
 
 
-def _recursively_update_units(units: set[str], db: QueryDB, expr: Expr) -> None:
-    if expr.is_leaf():
-        src = expr.get_src()
-        obj = src if isinstance(src, TimeVector) else db.get(key=src)
-        if isinstance(obj, Expr):
-            _recursively_update_units(units, db, obj)
-        elif isinstance(obj, Curve):
-            message = "Not yet implemented for Curve objects."
-            raise NotImplementedError(message)
-        elif isinstance(obj, TimeVector):
-            unit = obj.get_unit()
-            if unit is not None:
-                units.add(unit)
-        else:
-            message = f"Got unexpected object {obj}."
-            raise RuntimeError(message)
-    __, args = expr.get_operations(expect_ops=False, copy_list=False)
-    for arg in args:
-        _recursively_update_units(units, db, arg)
-
-
 def _recursively_update_timeindexes(timeindexes: set[TimeIndex], db: QueryDB, expr: Expr) -> None:
     if expr.is_leaf():
         src = expr.get_src()
@@ -315,7 +309,7 @@ def _recursively_update_timeindexes(timeindexes: set[TimeIndex], db: QueryDB, ex
         _recursively_update_timeindexes(timeindexes, db, arg)
 
 
-def _get_level_value_from_timevector(  # noqa: C901
+def _get_level_value_from_timevector(  # noqa: C901, PLR0915
     timevector: TimeVector,
     db: QueryDB,
     target_unit: str | None,
@@ -338,8 +332,8 @@ def _get_level_value_from_timevector(  # noqa: C901
     from_unit = timevector.get_unit()
 
     starttime = data_dim.get_start_time()  # OPPGAVE endrer ConstantTimeIndex-API?
-    timedelta = data_dim.get_period_duration()  # OPPGAVE endrer ConstantTimeIndex-API?
-    scalar = timeindex.get_period_average(values, starttime, timedelta, data_dim.is_52_week_years())
+    timedelta_ = data_dim.get_period_duration()  # OPPGAVE endrer ConstantTimeIndex-API?
+    scalar = timeindex.get_period_average(values, starttime, timedelta_, data_dim.is_52_week_years())
 
     if from_unit is not None and target_unit is not None:
         scalar *= get_unit_conversion_factor(from_unit, target_unit)
@@ -366,16 +360,59 @@ def _get_level_value_from_timevector(  # noqa: C901
                 # assert tv_ref_period_mean.size == 1
                 # assert tv_ref_period_mean[0] == 1
                 assert profile_expr, f"Profile Expr is None for TimeVector {timevector} when it should exist"
-                tv_target_ref_period_mean = get_profile_vector(
+
+                start_year = min(tv_ref_period.get_start_year(), target_ref_period.get_start_year())
+                end_year_1 = tv_ref_period.get_start_year() + tv_ref_period.get_num_years() - 1
+                end_year_2 = target_ref_period.get_start_year() + target_ref_period.get_num_years() - 1
+                end_year = max(end_year_1, end_year_2)
+                num_years = end_year - start_year + 1
+
+                pti = ProfileTimeIndex(
+                    start_year=start_year,
+                    num_years=num_years,
+                    period_duration=timedelta(weeks=1),
+                    is_52_week_years=scen_dim.is_52_week_years(),
+                )
+
+                profile_vector = get_profile_vector(
                     profile_expr,
                     db,
                     data_dim,
-                    scen_dim.copy_as_reference_period(target_ref_period),
+                    pti,
                     is_zero_one=False,
                     is_float32=is_float32,
                 )
-                assert tv_target_ref_period_mean.size == 1
-                avg_level = tv_target_ref_period_mean[0] * avg_level
+
+                assert np.isclose(profile_vector.mean(), 1.0)
+
+                ref_period_index = WeeklyIndex(
+                    start_year=tv_ref_period.get_start_year(),
+                    num_years=tv_ref_period.get_num_years(),
+                    is_52_week_years=scen_dim.is_52_week_years(),
+                )
+
+                avg_ref_period = pti.get_period_average(
+                    vector=profile_vector,
+                    start_time=ref_period_index.get_start_time(),
+                    duration=ref_period_index.total_duration(),
+                    is_52_week_years=ref_period_index.is_52_week_years(),
+                )
+
+                target_ref_period_index = WeeklyIndex(
+                    start_year=target_ref_period.get_start_year(),
+                    num_years=target_ref_period.get_num_years(),
+                    is_52_week_years=scen_dim.is_52_week_years(),
+                )
+
+                avg_target_ref_period = pti.get_period_average(
+                    vector=profile_vector,
+                    start_time=target_ref_period_index.get_start_time(),
+                    duration=target_ref_period_index.total_duration(),
+                    is_52_week_years=target_ref_period_index.is_52_week_years(),
+                )
+
+                scale = avg_target_ref_period / avg_ref_period
+                avg_level = scale * avg_level
             return avg_level
         # timevector fra max til avg
         max_level = scalar

framcore/expressions/units.py

@@ -1,3 +1,9 @@
+"""
+Define units used in the system, their handling and conversion rules.
+
+We use SymPy to support unit conversions. Already computed unit conversion factors are cached to minimize redundant calculations.
+"""
+
 from __future__ import annotations
 
 import contextlib
@@ -20,6 +26,7 @@ _SUPPORTED_UNITS = {
     "year": year,
     "y": year,
     "watt": watt,
+    "joule": watt * second,
     "g": gram,
     "gram": gram,
     "kg": kilo * gram,
@@ -28,6 +35,7 @@ _SUPPORTED_UNITS = {
     "meter": meter,
     "m": meter,
     "m3": meter**3,
+    "l": meter**3 / 1000,
     "Mm3": mega * meter**3,
     "m3/s": meter**3 / second,
     "kilo": kilo,
@@ -38,6 +46,10 @@ _SUPPORTED_UNITS = {
     "MWh": mega * watt * hour,
     "GWh": giga * watt * hour,
     "TWh": tera * watt * hour,
+    "J": watt * second,
+    "kJ": kilo * watt * second,
+    "MJ": mega * watt * second,
+    "GJ": giga * watt * second,
     "kW": kilo * watt,
     "MW": mega * watt,
     "GW": giga * watt,
@@ -55,6 +67,7 @@ _FASTPATH_CONVERSION_FACTORS = {
     ("GWh/year", "MW"): 0.11407955544967756,
     ("Mm3/year", "m3/s"): 0.03168876540268821,
     ("t/MWh", "t/GWh"): 1000.0,
+    ("MWh", "GJ"): 3.6,
 }
 
 _FASTPATH_INCOMPATIBLE_CONVERSIONS = {
@@ -70,14 +83,13 @@ _COLLECT_FASTPATH_DATA = False
 _OBSERVED_UNIT_CONVERSIONS = set()
 
 
-def get_unit_conversion_factor(from_unit: str | None, to_unit: str | None) -> float:
+def get_unit_conversion_factor(from_unit: str | None, to_unit: str | None) -> float:  # noqa C901
     """Get the conversion factor from one unit to another."""
     if from_unit == to_unit:
         return 1.0
 
     if from_unit is None or to_unit is None:
-        message = f"Incompatible units: from_unit {from_unit} to_unit {to_unit}"
-        raise ValueError(message)
+        return _get_unit_conversion_factor_with_none(from_unit, to_unit)
 
     fastpath = _fastpath_get_unit_conversion_factor(from_unit, to_unit)
 
@@ -116,6 +128,21 @@ def get_unit_conversion_factor(from_unit: str | None, to_unit: str | None) -> fl
     return fallback
 
 
+def _get_unit_conversion_factor_with_none(from_unit: str | None, to_unit: str | None) -> float:
+    if from_unit:
+        try:
+            return get_unit_conversion_factor(from_unit, "1")
+        except Exception:
+            pass
+    if to_unit:
+        try:
+            return get_unit_conversion_factor("1", to_unit)
+        except Exception:
+            pass
+    message = f"Incompatible units: from_unit {from_unit} to_unit {to_unit}"
+    raise ValueError(message)
+
+
 def _unit_has_no_floats(unit: str) -> bool:
     if not unit:
         return True

framcore/fingerprints/fingerprint.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import hashlib
-import json
 import pickle
 from enum import Enum
 

framcore/juliamodels/JuliaModel.py

@@ -1,4 +1,4 @@
-"""Manage Julia environment and usage of juliacall."""
+"""Manage Julia environment and usage of juliacall for Solvers implemented in the Julia language."""
 
 import importlib
 import os
@@ -43,14 +43,16 @@ class JuliaModel(Base):
         julia_path: Path | str | None = None,
         dependencies: list[str | tuple[str, str | None]] | None = None,
         skip_install_dependencies: bool = False,
+        force_julia_install: bool = True,
     ) -> None:
         """
         Initialize management of Julia model, environment and dependencies.
 
         The three parameters env_path, depot_path and julia_path sets environment variables for locations of your Julia
         environment, packages and language.
-            - If user has not specified locations, the default is to use the current python/conda environment.
-            - If a system installation of Python is used, the default is set to the current user location.
+
+        - If user has not specified locations, the default is to use the current python/conda environment.
+        - If a system installation of Python is used, the default is set to the current user location.
 
         Args:
             env_path (Path | str | None, optional): Path to location of Julia environment. If it doesnt exist it will be
@@ -61,6 +63,8 @@ class JuliaModel(Base):
                                                       doesnt exist. Defaults to None.
             dependencies (list[str] | None, optional): List of dependencies of the model. The strings in the list can be
                                                        either urls or Julia package names.. Defaults to None.
+            skip_install_dependencies (bool, optional): Skip installation of dependencies. Defaults to False.
+            force_julia_install (bool): Force new Julia install.
 
         """
         self._check_type(env_path, (Path, str, type(None)))
@@ -74,6 +78,7 @@ class JuliaModel(Base):
         self._julia_path = julia_path
         self._dependencies = dependencies if dependencies else []
         self._skip_install_dependencies = skip_install_dependencies
+        self._force_julia_install = force_julia_install
 
         self._jlpkg = None
         self._initialize_julia()
@@ -96,6 +101,11 @@ class JuliaModel(Base):
         if self._julia_path:  # If Julia path is not set, let JuliaCall handle defaults.
             os.environ["PYTHON_JULIAPKG_EXE"] = str(self._julia_path)
 
+        if self._force_julia_install:
+            path = os.environ.get("PATH", "")
+            cleaned = os.pathsep.join(p for p in path.split(os.pathsep) if "julia" not in p.lower())
+            os.environ["PATH"] = cleaned
+
         juliacall = importlib.import_module("juliacall")
         JuliaModel._jl = juliacall.Main
         self._jlpkg = juliacall.Pkg

framcore/loaders/loaders.py

@@ -47,8 +47,6 @@ class Loader(Base, ABC):
         """Clear cached data from the loader."""
         pass
 
-    # TODO: Is this correct? Also figure out how sharing Loaders should be when copying model given filepaths and copied
-    # database
     def __deepcopy__(self, memo: dict) -> Loader:
         """
         Overwrite deepcopy.

framcore/metadata/ExprMeta.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 from framcore.expressions import Expr
 from framcore.fingerprints import Fingerprint
-from framcore.metadata import Div
-from framcore.metadata.Meta import Meta  # NB! full import path needed for inheritance to work
+from framcore.metadata import Div, Meta
 
 
 class ExprMeta(Meta):
@@ -20,6 +19,8 @@ class ExprMeta(Meta):
 
     def __repr__(self) -> str:
         """Overwrite __repr__ for better string representation."""
+        if not hasattr(self, "_value"):
+            return f"{type(self).__name__}(uninitialized)"
         return f"{type(self).__name__}(expr={self._value})"
 
     def __eq__(self, other: object) -> bool:
@@ -28,7 +29,11 @@ class ExprMeta(Meta):
             return False
         return self._value == other._value
 
-    def get_value(self) -> float:
+    def __hash__(self) -> int:
+        """Compute the hash of the ExprMeta."""
+        return hash(self._value)
+
+    def get_value(self) -> Expr:
         """Return expr."""
         return self._value
 
@@ -40,10 +45,11 @@ class ExprMeta(Meta):
     def combine(self, other: Meta) -> Expr | Div:
         """Sum Expr."""
         if isinstance(other, ExprMeta):
-            return Expr(self._value + other.get_value())
-        d = Div(self)
-        d.set_value(other)
-        return d
+            return self._value + other.get_value()
+
+        div = Div(self)
+        div.set_value(other)
+        return div
 
     def get_fingerprint(self) -> Fingerprint:
         """Get the fingerprint of the ScalarMeta."""

framcore/metadata/LevelExprMeta.py

@@ -13,5 +13,20 @@ class LevelExprMeta(ExprMeta):
     """
 
     def __init__(self, value: Expr | TimeVector) -> None:
-        """Create new LevelExprMeta with float value."""
+        """
+        Create new LevelExprMeta with Expr value.
+
+        Args:
+            value (Expr | TimeVector): Accepts Expr with is_level=True or TimeVector with is_max_level=True/False.
+
+        Raises:
+            TypeError: If value is not Expr or TimeVector.
+            ValueError: If value is non-level Expr or TimeVector.
+
+        """
+        self._check_type(value, (Expr, TimeVector))
+
+        if isinstance(value, TimeVector) and value.is_max_level() is None:
+            raise ValueError("Parameter 'value' (TimeVector) must be a level (is_max_level must be True or False).")
+
         self._value = ensure_expr(value, is_level=True)

framcore/metadata/Member.py

@@ -7,17 +7,17 @@ from framcore.metadata.Meta import Meta  # NB! full import path needed for inher
 
 class Member(Meta):
     """
-    Member represent membership to a catergory with a str. Subclass of Meta.
+    Member represent membership to a catergory or group using a str. Subclass of Meta.
 
     Should not have missing values.
 
     When used, all components must have a membership.
     """
 
-    def __init__(self, value: str | float | int) -> None:  # TODO: only str
+    def __init__(self, value: str) -> None:
         """Create new member with str value."""
-        self._value = value  # set before checking, otherwise __repr__ can fail because self._value is not set.
-        self._check_type(value, (str, float, int))
+        self._value = value
+        self._check_type(value, str)
 
     def __repr__(self) -> str:
         """Overwrite __repr__ for better string representation."""
@@ -33,13 +33,13 @@ class Member(Meta):
         """Overwrite __hash__ since its added to sets."""
         return hash(self.__repr__())
 
-    def get_value(self) -> str | float | int:
+    def get_value(self) -> str:
         """Return str value."""
         return self._value
 
-    def set_value(self, value: str | float | int) -> None:
+    def set_value(self, value: str) -> None:
         """Set str value. TypeError if not str."""
-        self._check_type(value, (str, float, int))
+        self._check_type(value, str)
         self._value = value
 
     def combine(self, other: Meta) -> Member | Div:

framcore/metadata/__init__.py

@@ -1,10 +1,10 @@
 # framcore/metadata/__init__.py
 
+from framcore.metadata.Meta import Meta
 from framcore.metadata.Div import Div
 from framcore.metadata.ExprMeta import ExprMeta
 from framcore.metadata.LevelExprMeta import LevelExprMeta
 from framcore.metadata.Member import Member
-from framcore.metadata.Meta import Meta
 
 __all__ = [
     "Div",

framcore/querydbs/CacheDB.py

@@ -21,7 +21,7 @@ class CacheDB(QueryDB):
     def set_min_elapsed_seconds(self, value: float) -> None:
         """Values that takes below this threshold to compute, does not get cached."""
         self._check_type(value, float)
-        self._check_float(lower_bound=0.0)
+        self._check_float(value=value, lower_bound=0.0, upper_bound=None)
         self._min_elapsed_seconds = value
 
     def get_min_elapsed_seconds(self) -> float: