flextool 4.0.0__py3-none-any.whl

flextool/process_inputs/write_to_input_db.py

@@ -0,0 +1,269 @@
+import os
+from spinedb_api import DatabaseMapping, from_database, to_database, SpineDBAPIError, Asterisk
+from spinedb_api.exception import NothingToCommit
+from flextool.update_flextool import FLEXTOOL_DB_VERSION
+
+flextool_db_version = FLEXTOOL_DB_VERSION
+
+
+def _import_legacy_timeset_timeline(db, input_path: str) -> None:
+    """Set the ``timeset.timeline`` parameter from a legacy Excel sheet.
+
+    Pre-v25 specification-format Excels store the timeset->timeline link as a
+    two-column ``timeblockSet_timeline`` sheet (column 0 = timeset name,
+    column 1 = timeline name; a header row, no alternative column).  The
+    modern ``timeset_timeline`` sheet has a different layout, so this link is
+    not picked up by the generic spec mappings.
+
+    The v25 migration (``update_timestructure``) normally collapses the old
+    ``timeblockSet__timeline`` relationship into the ``timeset.timeline``
+    parameter, attaching each value to the alternative of that timeset's
+    duration.  Mirror that here so a pre-v25 Excel imports directly into the
+    v25+ schema: for every ``(timeset, alternative)`` that has a
+    ``timeset_duration`` value, set ``timeline`` in the same alternative.
+    Without it the solve fails with "Failed to map timeset to timeline".
+    """
+    import openpyxl
+
+    try:
+        wb = openpyxl.load_workbook(input_path, read_only=True, data_only=True)
+    except Exception:
+        return
+    try:
+        if "timeblockSet_timeline" not in wb.sheetnames:
+            return
+        timeset_to_timeline: dict[str, str] = {}
+        for i, row in enumerate(wb["timeblockSet_timeline"].iter_rows(values_only=True)):
+            if i == 0:  # header row: (timeblockSet, timeline)
+                continue
+            if not row or row[0] is None or row[1] is None:
+                continue
+            timeset_to_timeline[str(row[0])] = str(row[1])
+    finally:
+        wb.close()
+
+    if not timeset_to_timeline:
+        return
+
+    # Already-present (entity, alternative) pairs — stay idempotent.
+    existing = {
+        (pv["entity_byname"], pv["alternative_name"])
+        for pv in db.find_parameter_values(
+            entity_class_name="timeset", parameter_definition_name="timeline"
+        )
+    }
+    added = 0
+    for pv in db.find_parameter_values(
+        entity_class_name="timeset", parameter_definition_name="timeset_duration"
+    ):
+        byname = pv["entity_byname"]
+        timeline_name = timeset_to_timeline.get(byname[0])
+        if timeline_name is None:
+            continue
+        key = (byname, pv["alternative_name"])
+        if key in existing:
+            continue
+        value, type_ = to_database(timeline_name)
+        try:
+            db.add_parameter_value(
+                entity_class_name="timeset",
+                parameter_definition_name="timeline",
+                entity_byname=byname,
+                alternative_name=pv["alternative_name"],
+                value=value,
+                type=type_,
+            )
+            existing.add(key)
+            added += 1
+        except Exception as e:
+            print(f"  Could not set timeset.timeline for {byname[0]}: {e}")
+    if added:
+        print(
+            f"\nImported legacy timeset->timeline links "
+            f"({added} (timeset, alternative) pairs) from 'timeblockSet_timeline'."
+        )
+
+def write_to_flextool_input_db(input_path, tabular_reader, target_db_url, input_type='excel',
+                               migration_follows: bool = False):
+    """Write tabular data to FlexTool input database, reading one sheet/file at a time.
+
+    Args:
+        input_path: Path to Excel/ODS file or directory containing CSV files
+        tabular_reader: TabularReader instance with loaded specification
+        target_db_url: URL to target SQLite database
+        input_type: Either 'excel' or 'csv' to determine reading method
+        migration_follows: If True, accept a version mismatch because
+            the caller will migrate the database after import
+
+    This function reads sheets/files one at a time to minimize memory usage.
+    """
+    # Refuse specification-format Excels whose template layout predates the
+    # importer.  Deferred import avoids a circular dependency with the package.
+    if input_type == 'excel':
+        from flextool.process_inputs import (
+            MIN_SUPPORTED_SPECIFICATION_VERSION,
+            read_specification_changelog_version,
+            unsupported_specification_message,
+        )
+        changelog_version = read_specification_changelog_version(input_path)
+        if (
+            changelog_version is not None
+            and changelog_version < MIN_SUPPORTED_SPECIFICATION_VERSION
+        ):
+            print(unsupported_specification_message(changelog_version))
+            exit(1)
+
+    if target_db_url.startswith('sqlite://') or target_db_url.startswith('http://'):
+        db_url = target_db_url
+    elif os.path.exists(target_db_url) and target_db_url.endswith(".sqlite"):
+        db_url = 'sqlite:///' + target_db_url
+    else:
+        print("No sqlite file at " + target_db_url)
+        exit(-1)
+
+    with DatabaseMapping(db_url, create = False, upgrade = True) as db:
+        sq = db.object_parameter_definition_sq
+        version_parameter = db.query(sq).filter(sq.c.object_class_name == "model").filter(sq.c.parameter_name == "version").one_or_none()
+        if version_parameter is None:
+            #if no version assume version 0
+            print(f"No FlexTool database version found. Needs to be proper FlexTool database at version: {flextool_db_version}")
+            exit(-1)
+        else:
+            version = from_database(version_parameter.default_value, version_parameter.default_type)
+            if version == flextool_db_version:
+                print(f"Valid FlexTool input database with correct version: {flextool_db_version}")
+            elif migration_follows:
+                print(f"Importing into a fresh FlexTool schema-v{int(version)} database "
+                      "(a migration to the current version follows this import).")
+            else:
+                print(f"Wrong FlexTool input database version: {version}. Should be: {flextool_db_version}")
+                exit(-1)
+
+        # Get list of tables to process
+        selected_tables = tabular_reader.get_selected_table_names()
+        print(f"\nProcessing {len(selected_tables)} selected tables")
+
+        # Purge the database empty of data times
+        try:
+            db.remove_entity(id=Asterisk)
+            db.remove_alternative(id=Asterisk)
+            db.remove_scenario(id=Asterisk)
+            db.remove_parameter_value(id=Asterisk)
+            db.commit_session("Purged the db")
+        except Exception as e:
+            raise RuntimeError(f"Failed to purge the input database before writing. {e}")
+
+        # Process each table one at a time
+        for table_name in selected_tables:
+            print(f"\nProcessing table {table_name + ': ':<30}", end="")
+
+            # Read the sheet/file that contains the data
+            try:
+                if input_type == 'excel':
+                    raw_df, column_types = tabular_reader.read_excel_sheet(input_path, table_name)
+                elif input_type == 'csv':
+                    csv_file = os.path.join(input_path, f"{table_name}.csv")
+                    if not os.path.exists(csv_file):
+                        print(f"  Warning: CSV file not found: {csv_file}")
+                        continue
+                    raw_df, column_types = tabular_reader.read_csv_file(csv_file)
+                else:
+                    raise ValueError(f"Unknown input_type: {input_type}")
+
+                # Skip if sheet not found in the file
+                if raw_df is None:
+                    print(f"Skipping {table_name} - no sheet found")
+                    continue
+
+                # Skip if no data (e.g., sheet not selected)
+                if raw_df.empty:
+                    print(f"  Skipping {table_name} - no data")
+                    continue
+
+            except Exception as e:
+                print(f"  Error reading table '{table_name}': {e}")
+                continue  # Continue to next table on read error
+
+            # Get mappings for this sheet
+            mappings = tabular_reader.get_table_mappings(table_name)
+            if not mappings:
+                raise ValueError(f"No specification found for sheet {table_name}")
+
+            table_options = tabular_reader.get_table_options(table_name)
+            if 'row' in table_options:
+                raw_df = raw_df.iloc[table_options['row']:]
+            if 'column' in table_options:
+                raw_df = raw_df.iloc[table_options['column']:]
+
+            # Process each mapping in the table
+            for mapping_name in mappings.keys():
+                print(f"{mapping_name:>25}", end="")
+
+                mapping_info = tabular_reader._parse_mapping(mappings[mapping_name])
+                if not mapping_info:
+                    continue
+
+                # Read data and process the dataframe
+                try:
+                    (data_df, ent_zip_list, ent_act_zip, scen_array, scen_alt_df) = tabular_reader._extract_data(raw_df, mapping_info, table_options, column_types, table_name, mapping_name)
+                except Exception as e:
+                    print(
+                        f"\n  Error processing sheet '{table_name}', mapping "
+                        f"'{mapping_name}': {type(e).__name__}: {e}"
+                    )
+                    continue  # Continue to next mapping on processing error
+
+                if ent_zip_list:
+                    tabular_reader._add_entities(ent_zip_list, db, table_name, mapping_name)
+
+                # Add alternatives to the database
+                if data_df is not None:
+                    alt_array = data_df.columns.get_level_values('Alternative').unique().to_list()
+                    tabular_reader._add_alternatives(alt_array, db, table_name, mapping_name)
+
+                # Write re-organised dataframe to database
+                if data_df is not None:
+                #try:
+                    # check_type:
+                    value_type = mapping_info['rules'].get('ParameterValueType')
+                    if value_type:
+                        value_type = value_type['value']
+                    else:
+                        value_type = 'constant'
+                    tabular_reader._add_parameters(data_df, db, table_name, mapping_name, value_type)
+
+                # Ensure alternatives referenced by entity_alternatives exist
+                if ent_act_zip is not None:
+                    ent_act_list = list(ent_act_zip)
+                    ea_alts = list({alt for _cls, _ent, alt, _act in ent_act_list})
+                    if ea_alts:
+                        tabular_reader._add_alternatives(ea_alts, db, table_name, mapping_name)
+                    tabular_reader._add_entity_alternatives(ent_act_list, db, table_name, mapping_name)
+
+                # Add scenarios to the database
+                if scen_array is not None:
+                    for scen in scen_array:
+                        try:
+                            db.add_scenario(name=scen)
+                        except Exception as e:
+                            raise SpineDBAPIError(f'Could not add scenario {scen} to the database: {e}')
+
+                # Add scenario_alternatives to the database
+                if scen_alt_df is not None:
+                    tabular_reader._add_scenario_alternatives(scen_alt_df, db, table_name, mapping_name)
+
+        # Backfill the timeset->timeline link from the legacy two-column sheet
+        # if present (pre-v25 Excels); modern files set it via the spec.
+        if input_type == 'excel':
+            _import_legacy_timeset_timeline(db, input_path)
+
+        # Commit the changes
+        try:
+            db.commit_session(f"Imported data from mapping '{mapping_name}'")
+            tabular_reader.logger.info(f"Successfully committed data and items from mapping {mapping_name}")
+        except NothingToCommit:
+            pass
+        except Exception as e:
+            raise SpineDBAPIError(f"Could not commit data and items based on {mapping_name}: {e}")
+
+    print("\nAll data processed successfully!    (* = No data found for the mapping)")

flextool/process_outputs/__init__.py

@@ -0,0 +1,7 @@
+"""Output data processing: reads solver CSV results, post-processes, and writes outputs."""
+from flextool.process_outputs.read_variables import read_variables
+from flextool.process_outputs.read_parameters import read_parameters
+from flextool.process_outputs.read_sets import read_sets
+from flextool.process_outputs.process_results import post_process_results
+from flextool.process_outputs.write_outputs import write_outputs
+__all__ = ['read_variables', 'read_parameters', 'read_sets', 'post_process_results', 'write_outputs']

flextool/process_outputs/_annualize.py

@@ -0,0 +1,55 @@
+"""Shared dt→d annualisation helper for the output-processing stage.
+
+A single place that performs the *extensive* per-step → per-period→annual
+aggregation so that no individual output site drifts from the cost-weighting
+convention.
+
+The LP objective annualises every per-timestep cost term with the
+representative weight ``p_timestep_weight[d, t]`` (1.0 for a full / evenly
+sampled timeline, a per-step share of the year for a representative timeset
+with ``timeset_weights``).  Annual *energy / extensive* outputs must use the
+**same** weight so that the energy the model is scaled to serve, reports, and
+costs all coincide.  When ``w ≡ 1`` (the common full-timeline case) the result
+is byte-identical to the unweighted formula.
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+
+def annualize_dt_to_d(
+    frame: pd.DataFrame,
+    timestep_weight: pd.Series,
+    complete_period_share_of_year: pd.Series,
+    step_duration: "pd.Series | None" = None,
+    *,
+    div_level: "int | None" = None,
+) -> pd.DataFrame:
+    """Weight a per-``(d, t)`` extensive frame and annualise it to per-period.
+
+    Steps (matching the objective's annualisation):
+
+    1. If ``step_duration`` is given (the frame holds power, MW), multiply by
+       it to obtain energy per step (MWh).  Inflow-type frames are already
+       MWh/step — pass ``step_duration=None``.
+    2. Multiply by ``timestep_weight`` (the per-``(d, t)`` representative weight,
+       1.0 when no/uniform ``timeset_weights``).
+    3. Sum over the ``period`` level.
+    4. Divide by ``complete_period_share_of_year`` (the uniform annualiser
+       ``Σ_t step_duration / 8760``).
+
+    ``timestep_weight`` and ``step_duration`` share the identical
+    ``(period, time)`` row index (both stripped of the ``solve`` level in
+    ``drop_levels``), so ``.mul(..., axis=0)`` broadcasts the same way.
+
+    ``div_level`` mirrors the per-site ``.div(..., axis=0, level=...)``
+    convention: pass ``level=1`` where the caller's frame has a multi-level
+    row index whose period sits at level 1 (e.g. ``out_node`` slacks).
+    """
+    f = frame if step_duration is None else frame.mul(step_duration, axis=0)
+    f = f.mul(timestep_weight, axis=0)
+    summed = f.groupby(level="period").sum()
+    if div_level is None:
+        return summed.div(complete_period_share_of_year, axis=0)
+    return summed.div(complete_period_share_of_year, axis=0, level=div_level)

flextool/process_outputs/_inmemory_helpers.py

@@ -0,0 +1,292 @@
+"""Δ.31 — In-memory FlexData → pandas helpers for read_parameters / read_sets.
+
+These helpers translate the polars long-form FlexData fields into the
+pandas wide-format shapes that the legacy CSV-based ``read_parameters``
+and ``read_sets`` produced.  They are stateless utilities; the
+per-attribute mapping lives in
+:mod:`flextool.process_outputs.read_parameters` and
+:mod:`flextool.process_outputs.read_sets`.
+
+Naming convention: dim columns in FlexData are short (``n``, ``p``,
+``d``, ``t``, ``g``, ``c``, ``e``, …).  The legacy pandas namespace
+spells them out in full (``node``, ``process``, ``period``, ``time``,
+``group``, ``commodity``, ``entity``, …).  :data:`DIM_NAMES` is the
+canonical translation table.
+
+Failure mode: every helper raises (``KeyError``, ``ValueError``)
+loudly when a FlexData field is absent or has an unexpected schema.
+The legacy CSV path was tolerant of empty / missing files — the
+in-memory replacement is strict so authoring bugs surface at the
+call-site instead of producing silently-empty outputs.
+"""
+from __future__ import annotations
+
+from typing import Sequence
+
+import pandas as pd
+import polars as pl
+
+
+# ---------------------------------------------------------------------------
+# Canonical dim-name translation table.
+#
+# FlexData uses short, model-internal names (``n``, ``p``, ``d``, ``t``).
+# Legacy pandas output namespace spells them out so plot / write_outputs
+# / out_*.py modules read them as ``period`` / ``time`` / ``node`` /
+# ``process`` etc.  Keep this map in sync with the per-field comments in
+# :class:`flextool.engine_polars.input.FlexData`.
+DIM_NAMES: dict[str, str] = {
+    "n": "node",
+    "p": "process",
+    "g": "group",
+    "c": "commodity",
+    "f": "profile",
+    "d": "period",
+    "t": "time",
+    "e": "entity",
+    "i": "tier",
+    "ud": "upDown",
+    "r": "reserve",
+    "source": "source",
+    "sink": "sink",
+    "method": "method",
+    "param": "param",
+    # Storage / time-helper extensions
+    "td": "td",
+    # Block / branch / lookback names that already match
+    "b_first": "b_first",
+}
+
+
+def long_dim(d: str) -> str:
+    """Return the long pandas dim-name for a FlexData short dim."""
+    if d in DIM_NAMES:
+        return DIM_NAMES[d]
+    return d
+
+
+# ---------------------------------------------------------------------------
+# Frame → pandas helpers
+# ---------------------------------------------------------------------------
+
+
+def _to_pandas(frame_pl: "pl.DataFrame") -> pd.DataFrame:
+    """``polars.DataFrame.to_pandas()`` with a small empty-frame guard."""
+    if frame_pl is None:
+        raise ValueError("expected a polars DataFrame, got None")
+    return frame_pl.to_pandas()
+
+
+def wide_per_entity(
+    frame_pl: "pl.DataFrame",
+    *,
+    row_dims: Sequence[str],
+    col_dim: str,
+    value: str = "value",
+    row_names: Sequence[str] | None = None,
+    col_name: str | None = None,
+) -> pd.DataFrame:
+    """Pivot a polars long-form frame to a single-level-column pandas
+    DataFrame.
+
+    Parameters
+    ----------
+    frame_pl : polars.DataFrame
+        Source frame; must carry ``row_dims + (col_dim, value)``.
+    row_dims : sequence of str
+        Dim columns that become the (multi-)row-index.
+    col_dim : str
+        Dim column that becomes the column header.
+    value : str, default "value"
+        Column carrying the numeric values.
+    row_names : sequence of str, optional
+        If supplied, the row index level names are set to these.
+        Otherwise the source dim names are used (translated via
+        :data:`DIM_NAMES`).
+    col_name : str, optional
+        Column index name (e.g. ``"node"``, ``"entity"``).  Defaults
+        to the translated ``col_dim``.
+    """
+    pdf = _to_pandas(frame_pl)
+    pivoted = pdf.pivot(index=list(row_dims), columns=col_dim, values=value)
+    pivoted = pivoted.astype(float)
+    if row_names is not None:
+        pivoted.index.names = list(row_names)
+    else:
+        pivoted.index.names = [long_dim(d) for d in row_dims]
+    pivoted.columns.name = col_name if col_name is not None else long_dim(col_dim)
+    return pivoted
+
+
+def wide_multi_col(
+    frame_pl: "pl.DataFrame",
+    *,
+    row_dims: Sequence[str],
+    col_dims: Sequence[str],
+    value: str = "value",
+    row_names: Sequence[str] | None = None,
+    col_names: Sequence[str] | None = None,
+) -> pd.DataFrame:
+    """Pivot a polars long-form frame to a wide-column pandas DataFrame
+    where the columns are a MultiIndex of ``col_dims``.
+
+    Used for ``flow_min`` / ``flow_max`` / ``process_source_sink_varCost`` /
+    ``reserve_upDown_group_reservation`` (column MultiIndex of 3 levels).
+    """
+    pdf = _to_pandas(frame_pl)
+    pivoted = pdf.pivot(index=list(row_dims), columns=list(col_dims), values=value)
+    pivoted = pivoted.astype(float)
+    if row_names is not None:
+        pivoted.index.names = list(row_names)
+    else:
+        pivoted.index.names = [long_dim(d) for d in row_dims]
+    if col_names is not None:
+        pivoted.columns.names = list(col_names)
+    else:
+        pivoted.columns.names = [long_dim(d) for d in col_dims]
+    return pivoted
+
+
+def series_with_index(
+    frame_pl: "pl.DataFrame",
+    *,
+    dim: str,
+    value: str = "value",
+    name: str | None = None,
+) -> pd.Series:
+    """Polars long-form (single-dim) → pandas Series with a named index."""
+    pdf = _to_pandas(frame_pl)
+    s = pdf.set_index(dim)[value].astype(float)
+    s.index.name = name if name is not None else long_dim(dim)
+    return s
+
+
+def series_from_two_dim(
+    frame_pl: "pl.DataFrame",
+    *,
+    dims: Sequence[str],
+    value: str = "value",
+    names: Sequence[str] | None = None,
+) -> pd.Series:
+    """Polars long-form (multi-dim) → pandas Series with MultiIndex."""
+    pdf = _to_pandas(frame_pl)
+    s = pdf.set_index(list(dims))[value].astype(float)
+    if names is not None:
+        s.index.names = list(names)
+    else:
+        s.index.names = [long_dim(d) for d in dims]
+    return s
+
+
+def series_with_multi_index(
+    frame_pl: "pl.DataFrame",
+    *,
+    dims: Sequence[str],
+    value: str = "value",
+    names: Sequence[str] | None = None,
+) -> pd.Series:
+    """polars long-form → pandas Series whose index is a MultiIndex.
+
+    The legacy CSV path produced these for parameters with
+    ``header=[0, 1, 2], index_col=0`` and a single ``value`` row that
+    pandas exposed as a Series — e.g. ``process_sink_conversion_flow_coeff``,
+    ``reserve_upDown_group_penalty``.  The Series's index carries the
+    multi-key tuple per cell; the in-memory equivalent is a Series with
+    a MultiIndex.
+    """
+    return series_from_two_dim(frame_pl, dims=dims, value=value, names=names)
+
+
+# ---------------------------------------------------------------------------
+# Set helpers (read_sets)
+# ---------------------------------------------------------------------------
+
+
+def to_index(frame_pl: "pl.DataFrame", *, dim: str, name: str | None = None) -> pd.Index:
+    """Polars (single-dim) → pandas Index with a named axis."""
+    pdf = _to_pandas(frame_pl.select(dim))
+    return pd.Index(pdf[dim].tolist(), name=name if name is not None else long_dim(dim))
+
+
+def to_multi_index(
+    frame_pl: "pl.DataFrame",
+    *,
+    dims: Sequence[str],
+    names: Sequence[str] | None = None,
+) -> pd.MultiIndex:
+    """Polars long-form → pandas MultiIndex over the supplied dims.
+
+    The frame is restricted to the ``dims`` columns (de-duplicated /
+    not — left to the caller; we don't introduce extra ordering).
+    """
+    pdf = _to_pandas(frame_pl.select(list(dims)))
+    if names is None:
+        names = [long_dim(d) for d in dims]
+    return pd.MultiIndex.from_frame(pdf, names=list(names))
+
+
+def empty_index(name: str | None = None, dtype: str = "object") -> pd.Index:
+    """Empty :class:`pd.Index` with a stable ``name`` / ``dtype``."""
+    return pd.Index([], dtype=dtype, name=name)
+
+
+def empty_multi_index(names: Sequence[str]) -> pd.MultiIndex:
+    """Empty :class:`pd.MultiIndex` with ``len(names)`` levels."""
+    return pd.MultiIndex.from_arrays([[]] * len(names), names=list(names))
+
+
+# ---------------------------------------------------------------------------
+# Solve-name injection
+# ---------------------------------------------------------------------------
+
+
+def with_solve_column(frame_pl: "pl.DataFrame", solve_name: str) -> "pl.DataFrame":
+    """Return ``frame_pl`` with a leading ``solve`` column = ``solve_name``.
+
+    FlexData fields drop the ``solve`` column at load time (see
+    ``input.py:_read_long`` family).  The legacy pandas namespace
+    keeps it as the leftmost index level.  Inject it back in so the
+    pivoted DataFrame's row MultiIndex starts with ``solve``.
+    """
+    if frame_pl is None:
+        return None
+    return frame_pl.with_columns(pl.lit(solve_name).alias("solve"))
+
+
+def add_solve_to_pandas(df: "pd.DataFrame | pd.Series", solve_name: str) -> "pd.DataFrame | pd.Series":
+    """Prepend a constant ``solve`` level to the row index.
+
+    Used when the frame already carries other dims and we want to
+    inject the solve level *after* pivoting (so wide-column pivots
+    don't wear the constant column unnecessarily).
+    """
+    if isinstance(df.index, pd.MultiIndex):
+        new = pd.MultiIndex.from_arrays(
+            [[solve_name] * len(df.index)] + [df.index.get_level_values(i) for i in range(df.index.nlevels)],
+            names=["solve"] + list(df.index.names),
+        )
+    else:
+        new = pd.MultiIndex.from_arrays(
+            [[solve_name] * len(df.index), list(df.index)],
+            names=["solve", df.index.name],
+        )
+    out = df.copy()
+    out.index = new
+    return out
+
+
+__all__ = [
+    "DIM_NAMES",
+    "long_dim",
+    "wide_per_entity",
+    "wide_multi_col",
+    "series_with_index",
+    "series_from_two_dim",
+    "series_with_multi_index",
+    "to_index",
+    "to_multi_index",
+    "empty_index",
+    "empty_multi_index",
+    "with_solve_column",
+    "add_solve_to_pandas",
+]