data-disaggregation 0.11.0__tar.gz → 0.12.0__tar.gz

{data_disaggregation-0.11.0 → data_disaggregation-0.12.0}/PKG-INFO

@@ -1,34 +1,34 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: data-disaggregation
-Version: 0.11.0
+Version: 0.12.0
 Author: Christian Winger
 License: MIT
 Project-URL: Documentation, https://wingechr.github.io/data-disaggregation
 Project-URL: Source, https://github.com/wingechr/data-disaggregation
-Platform: any
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pandas
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license
-Dynamic: platform
-Dynamic: project-url
-Dynamic: requires-dist
+Requires-Dist: pandas>=2.0
+Dynamic: license-file
 
-# README
+# DataDisAggregation Package
 
-[![](https://img.shields.io/github/license/wingechr/data-disaggregation)](./LICENSE)
+[![](https://img.shields.io/github/license/wingechr/data-disaggregation)](https://github.com/wingechr/data-disaggregation/blob/main/LICENSE)
 [![](https://img.shields.io/pypi/pyversions/data-disaggregation)](https://github.com/wingechr/data-disaggregation)
 [![](https://img.shields.io/pypi/v/data-disaggregation)](https://pypi.org/project/data-disaggregation/)
 [![](https://img.shields.io/github/actions/workflow/status/wingechr/data-disaggregation/test.yml?label=tests)](https://github.com/wingechr/data-disaggregation/actions/workflows/test.yml)
 [![](https://img.shields.io/github/actions/workflow/status/wingechr/data-disaggregation/publish.yml?label=docs)](https://wingechr.github.io/data-disaggregation/)
 
+DataDisAggregation is a python package that lets you perform weighted aggregations and
+weighted disaggregations of data.
+
+Development was funded as part of the IND-E project.
+
+![](static/BMWK_Fz_2017_Web2x_en.gif)
+
 ## Install
 
 ```bash

{data_disaggregation-0.11.0 → data_disaggregation-0.12.0}/README.md

@@ -1,11 +1,18 @@
-# README
+# DataDisAggregation Package
 
-[![](https://img.shields.io/github/license/wingechr/data-disaggregation)](./LICENSE)
+[![](https://img.shields.io/github/license/wingechr/data-disaggregation)](https://github.com/wingechr/data-disaggregation/blob/main/LICENSE)
 [![](https://img.shields.io/pypi/pyversions/data-disaggregation)](https://github.com/wingechr/data-disaggregation)
 [![](https://img.shields.io/pypi/v/data-disaggregation)](https://pypi.org/project/data-disaggregation/)
 [![](https://img.shields.io/github/actions/workflow/status/wingechr/data-disaggregation/test.yml?label=tests)](https://github.com/wingechr/data-disaggregation/actions/workflows/test.yml)
 [![](https://img.shields.io/github/actions/workflow/status/wingechr/data-disaggregation/publish.yml?label=docs)](https://wingechr.github.io/data-disaggregation/)
 
+DataDisAggregation is a python package that lets you perform weighted aggregations and
+weighted disaggregations of data.
+
+Development was funded as part of the IND-E project.
+
+![](static/BMWK_Fz_2017_Web2x_en.gif)
+
 ## Install
 
 ```bash

{data_disaggregation-0.11.0 → data_disaggregation-0.12.0}/data_disaggregation/__init__.py

@@ -1,5 +1,4 @@
-__version__ = "0.11.0"
-
 from . import actions, vtypes
 
+__version__ = "0.12.0"
 __all__ = ["actions", "vtypes"]

{data_disaggregation-0.11.0 → data_disaggregation-0.12.0}/data_disaggregation/actions.py

@@ -1,5 +1,4 @@
-"""Functions to perform data transformations.
-"""
+"""Functions to perform data transformations."""
 
 from .base import transform
 from .ext import transform_pandas

data_disaggregation-0.12.0/data_disaggregation/base.py

@@ -0,0 +1,263 @@
+"""base code without dependencies.
+
+* a Variable is a (dict like) mapping from a Domain -> Value from a given Range
+* a Transformation maps a Variable to a a new Variable in a different Domain
+* Domains can be have multiple, nested dimensions
+
+* DomainMap is a Variable that maps (Domain1 x Domain2) to a numerical value (size)
+* DomainSize is a Variable that maps a Domain to a numerical value (size)
+    this is only needed for Variables of type MetricExtVarType
+
+
+Algorithm
+
+* We want to map variable of U(Dom1) (of type T) to V(Dom2) (will also be of Type T)
+* Inputs:
+    * U(Dom1) and T
+    * Dom1Size(Dom1)
+    * Dom2Size(Dom2)
+    * Dom1Dom2Map(Dom1 x Dom2)
+* Output
+    * V(Dom2) of type T
+* Steps
+    * start with Dom1Dom2Map, join U (this will replicate values!)
+    * IF T==MetricExtVarType:
+        * join Dom1Size and Dom2Size and rescale U: U' = U / Dom1Size * Dom2Size
+    * GROUP BY Dom2 and use the respective aggregation functions of the type,
+      with U being the value and  Dom1Dom2Map being the weight
+* Optional Steps
+    * if Type is numeric but limited to int: round values
+    * if specified: gapfill missing values from Dom2 with na or a suitable default
+    * if specified, a threshold for sum(weights)/size(dom2) can be set (usually 0.5)
+      to drop elements from output
+
+Helper to create the mapping
+* Given a (multidim) input domain and a (multidim) output domain
+* and a weight mapping over a (arbitrary) weight domain:
+* organize into a unique list by shared dims: dims_in, dims_out
+    => [dims_in_only] + [dims_shared] + [dims_out_only]
+* weightdin MUST be a subset of this, but MAY have fewers
+
+* Steps:
+    * create super domain of cross product of all of those
+    * join weights
+    * create index pairs for result
+
+"""
+
+from __future__ import annotations  # Series[...] for older python/pandas
+
+from typing import Any
+
+import pandas as pd
+from pandas import DataFrame, Index, MultiIndex, Series
+
+from .utils import SeriesDict, SeriesFrame, as_series
+from .vtypes import VariableType
+
+_NA_DIM_KEY = "__NA__"
+
+
+def get_NA_DIM_KEY(for_index: Index) -> Any:
+    sample = for_index[0]
+    if isinstance(sample, tuple):
+        return tuple([_NA_DIM_KEY] * len(sample))
+    return _NA_DIM_KEY
+
+
+def _assert_index_unique_no_na(index: Index, name: str):
+    if not index.is_unique:
+        raise Exception(f"index not unique in {name}: {set(index.duplicated())}")
+    for level in range(index.nlevels):
+        if any(index.get_level_values(level).isna()):
+            raise Exception(f"index contains NA in {name}")
+    if get_NA_DIM_KEY(index) in index:
+        raise Exception(f"index contains {get_NA_DIM_KEY(index)} in {name}")
+
+
+def _assert_all_gt0(data: SeriesFrame, name: str):
+    if not all(data > 0):
+        raise Exception(f"Not all values are > 0 in {name}")
+
+
+def _assert_all_ge0(data: SeriesFrame, name: str):
+    if not all(data >= 0):
+        raise Exception(f"Not all values are >= 0 in {name}")
+
+
+def _assert_index_subset(index: Index, ref_index: Index, name: str):
+    err = set(index) - set(ref_index)
+    if err:
+        raise Exception(f"Unexepcted, additional elements in {name}: {err}")
+
+
+def _check_initialize_weights(
+    df_weight_map: DataFrame,
+    ds_weights_from: Series[float],
+    ds_weights_to: Series[float],
+) -> tuple[DataFrame, Series, Series]:
+    # convert weights to frame, rows = from, cols = to, realign
+    df_weight_map = df_weight_map.reindex(
+        index=ds_weights_from.index, columns=ds_weights_to.index
+    ).fillna(0)
+
+    # all indices must be unique and not NA
+    _assert_index_unique_no_na(df_weight_map.index, "weights (source)")
+    _assert_index_unique_no_na(df_weight_map.columns, "weights (target)")
+    _assert_index_unique_no_na(ds_weights_from.index, "weights (sum source)")
+    _assert_index_unique_no_na(ds_weights_to.index, "weights (sum target)")
+    _assert_all_gt0(ds_weights_from, "weights (sum source)")
+    _assert_all_gt0(ds_weights_to, "weights (sum target)")
+    _assert_all_ge0(df_weight_map, "weights")
+    # weights have to be in ds_weights_from / ds_weights_to sums
+    _assert_index_subset(df_weight_map.index, ds_weights_from.index, "weights (source)")
+    _assert_index_subset(df_weight_map.columns, ds_weights_to.index, "weights (target)")
+
+    # differences of sum weights and weigh sums
+    ds_weights_from_rest = ds_weights_from - df_weight_map.sum(axis=1)
+    _assert_all_ge0(ds_weights_from_rest, "col weights for NA")
+    ds_weights_to_rest = ds_weights_to - df_weight_map.sum(axis=0)
+    _assert_all_ge0(ds_weights_to_rest, "row weights for NA")
+
+    # add additional row for NA in source
+    df_weight_map = pd.concat(
+        [
+            df_weight_map,
+            ds_weights_to_rest.to_frame().T.set_axis(
+                [get_NA_DIM_KEY(df_weight_map.index)]
+            ),
+        ]
+    )
+    ds_weights_from_rest = pd.concat(
+        [
+            ds_weights_from_rest,
+            Series(0, index=[get_NA_DIM_KEY(ds_weights_from_rest.index)]),
+        ]
+    )
+
+    # add NA output col (temp)
+    df_weight_map_w_na_column = pd.concat(
+        [
+            df_weight_map,
+            ds_weights_from_rest.rename(
+                get_NA_DIM_KEY(df_weight_map.columns)  # type: ignore (yes, NA should be col identifier)
+            ),
+        ],
+        axis=1,
+    )
+
+    # df_weight_map.columns = ds_weights_to.index
+    df_weight_map.columns.names = ds_weights_to.index.names
+
+    ds_weights_from = df_weight_map_w_na_column.sum(axis=1)
+    ds_weights_to = df_weight_map.sum(axis=0)
+
+    return df_weight_map, ds_weights_from, ds_weights_to
+
+
+class Transformer:
+    def __init__(
+        self,
+        vtype: type[VariableType],
+        df_weight_map: DataFrame,
+        ds_weights_from: Series | None = None,
+        ds_weights_to: Series | None = None,
+        weight_rel_threshold: float = 0.0,
+    ):
+        ds_weights_from = (
+            df_weight_map.sum(axis=1) if ds_weights_from is None else ds_weights_from
+        )
+        ds_weights_to = (
+            df_weight_map.sum(axis=0) if ds_weights_to is None else ds_weights_to
+        )
+        df_weight_map, ds_weights_from, ds_weights_to = _check_initialize_weights(
+            df_weight_map, ds_weights_from, ds_weights_to
+        )
+
+        self.df_weight_map: DataFrame = df_weight_map
+        self.ds_weights_from: Series = ds_weights_from
+        self.ds_weights_to: Series = ds_weights_to
+        self.vtype: type[VariableType] = vtype
+        self.weight_rel_threshold: float = weight_rel_threshold
+
+    def __call__(self, ds_data: Series) -> Series:
+        _assert_index_unique_no_na(ds_data.index, str(ds_data.name))
+        return (
+            self.vtype.transform(
+                ds_data=ds_data,
+                df_weight_map=self.df_weight_map,
+                ds_weights_from=self.ds_weights_from,
+                # ds_weights_to=self.ds_weights_to,
+                weight_rel_threshold=self.weight_rel_threshold,
+            )
+            .rename(ds_data.name)  # type:ignore
+            .rename_axis(index=self.df_weight_map.columns.names)
+        )  # type:ignore
+
+
+def transform(
+    vtype: type[VariableType],
+    data: SeriesDict,
+    weight_map: SeriesDict,
+    weights_from: SeriesDict | None = None,
+    weights_to: SeriesDict | None = None,
+    weight_rel_threshold: float = 0.0,
+) -> SeriesDict:
+    """(dis-)aggregate data.
+
+    Parameters
+    ----------
+    vtype: VariableType
+        Variable type of input data, determines the aggregation method.
+    data: Mapping[F, V]
+        Input data: mapping (usually dict) from any keys (any hashable) to values.
+    weight_map: Mapping[Tuple[F, T], float]
+        weights for combinations of input and output elements (must be positive).
+        Keys must tuples from input/output key pairs.
+    weights_from: Mapping[F, float]
+        optional weights of input elements (must be positive).
+        If not specified, this will be calculated as a sum from `weight_map`.
+    weights_to: Mapping[T, float]
+        optional weights of output elements (must be positive).
+        If not specified, this will be calculated as a sum from `weight_map`.
+    weight_rel_threshold: float
+        optional value between 0 and 1: all mappings are dropped
+        if the sum of input weights / output weight is smaller than this threshold.
+        For example, you may want to set it to 0.5 for geographical mappings with
+        extensive data.
+
+    Returns
+    -------
+    : Mapping[T, V]
+        output data as a mapping from output keys (any hashable) to values.
+
+    """
+
+    ds_data = as_series(data)
+    # harmonize NaN/None/NA and drop from data
+    ds_data = ds_data.convert_dtypes().dropna()  # normalize and drop na
+
+    ds_weight_map = as_series(weight_map)
+    df_weight_map = ds_weight_map.unstack(level=1)
+    # fix problem with multiindex
+    if isinstance(ds_data.index, MultiIndex) and not isinstance(
+        df_weight_map.index, MultiIndex
+    ):
+        df_weight_map.index = pd.MultiIndex.from_tuples(df_weight_map.index)
+
+    ds_weights_from = None if weights_from is None else as_series(weights_from)
+    ds_weights_to = None if weights_to is None else as_series(weights_to)
+
+    transformer = Transformer(
+        vtype=vtype,
+        df_weight_map=df_weight_map,
+        ds_weights_from=ds_weights_from,
+        ds_weights_to=ds_weights_to,
+        weight_rel_threshold=weight_rel_threshold,
+    )
+
+    ds_result = transformer(ds_data)
+
+    result = type(data)(ds_result)
+
+    return result

{data_disaggregation-0.11.0 → data_disaggregation-0.12.0}/data_disaggregation/ext.py

@@ -1,14 +1,13 @@
-"""extended functions, especially for pandas Series
-"""
+"""extended functions, especially for pandas Series"""
 
-from typing import List, Tuple, Union
+from typing import cast
 
 import numpy as np
 from pandas import DataFrame, Index, MultiIndex, Series
 
-from .base import transform
-from .utils import is_scalar
-from .vtypes import SCALAR_DIM_NAME, SCALAR_INDEX_KEY, VariableType
+from .base import Transformer
+from .utils import SCALAR_DIM_NAME, SCALAR_INDEX_KEY, SeriesFrame, is_scalar
+from .vtypes import VariableType
 
 IDX_SCALAR = MultiIndex.from_product([Index([SCALAR_INDEX_KEY], name=SCALAR_DIM_NAME)])
 COL_WEIGHT = "__WEIGHT__"
@@ -16,17 +15,17 @@ COL_FROM = "__FROM__"
 COL_TO = "__TO__"
 
 
-def harmonize_input_data(data: Union[DataFrame, Series, float]) -> DataFrame:
-    """
-    return DataFrame with MultiIndex
-    """
+def harmonize_input_data(data: DataFrame | Series | float) -> DataFrame:
+    """return DataFrame with MultiIndex"""
     if is_scalar(data):
-        data = DataFrame({SCALAR_INDEX_KEY: data}, index=IDX_SCALAR)
+        df = DataFrame({SCALAR_INDEX_KEY: data}, index=IDX_SCALAR)
     elif isinstance(data, Series):
-        data = data.to_frame()
+        df = data.to_frame()
+    elif not isinstance(data, DataFrame):
+        raise TypeError(type(data))
     # ensure multiindex
-    data = ensure_multiindex(data)
-    return data
+    df = ensure_multiindex(df)
+    return df
 
 
 def as_multiindex(index: Index) -> MultiIndex:
@@ -35,7 +34,7 @@ def as_multiindex(index: Index) -> MultiIndex:
     return index
 
 
-def ensure_multiindex(item: Union[DataFrame, Series]) -> Union[DataFrame, Series]:
+def ensure_multiindex(item: SeriesFrame) -> SeriesFrame:
     if not isinstance(item.index, MultiIndex):
         index = as_multiindex(item.index)
         item = item.copy()  # TODO: can we replace index without copy?
@@ -44,51 +43,56 @@ def ensure_multiindex(item: Union[DataFrame, Series]) -> Union[DataFrame, Series
 
 
 def as_list_of_series_w_multiindex(
-    items: Union[Index, Series, Tuple[Union[Index, Series]]]
-) -> List[Series]:
+    items: Index | Series | list[Index | Series],
+) -> list[Series]:
     # make sure we have a list/tuple
-    if not isinstance(items, (list, tuple)):
-        items = [items]
+    list_items = [items] if not isinstance(items, (list, tuple)) else items
     # make sure we have series:
-    items = [it if isinstance(it, Series) else Series(1, index=it) for it in items]
-    items = [ensure_multiindex(it) for it in items]
-    return items
+    list_items = [
+        it if isinstance(it, Series) else Series(1, index=it) for it in list_items
+    ]
+    list_items = [ensure_multiindex(it) for it in list_items]
+    return list_items
 
 
-def merge_indices(items: List[Union[Series, Index]]) -> MultiIndex:
+def merge_indices(
+    items: list[Series] | list[Index] | list[Index | Series],
+) -> MultiIndex:
     """Create product of unions of indices"""
     # ensure items are multiindices
-    items = [it if isinstance(it, Index) else it.index for it in items]
-    items = [as_multiindex(it) for it in items]
+    list_items = [it if isinstance(it, Index) else it.index for it in items]
+    list_items = [as_multiindex(it) for it in list_items]
     indices = {}
-    for it in items:
+    for it in list_items:
         for idx in it.levels:
             if idx.name not in indices:
                 indices[idx.name] = idx
             else:
                 indices[idx.name] = indices[idx.name].union(idx)
-    return MultiIndex.from_product(indices.values())
+    return MultiIndex.from_product(list(indices.values()))
 
 
 def combine_weights(
-    weights: Union[Index, Series, Tuple[Union[Index, Series]]]
+    weights: Index | Series | list[Index | Series],
 ) -> Series:
     """multiply all weights series
+
     * join on overlapping columns (or all if none
     * if index and not series: use value 1
 
     Returns:
         Series with MultiIndex
+
     """
     # make sure we have series:
-    weights = as_list_of_series_w_multiindex(weights)
+    weights_list = as_list_of_series_w_multiindex(weights)
 
     # merge indices
-    idx = merge_indices(weights)
+    idx = merge_indices(weights_list)
 
     # multiply all and drop nan
     result = Series(1, index=idx)
-    for w in weights:
+    for w in weights_list:
         # IMPORTANT: `result *= w` gives a different result, so DONT use it
         result = result * w
 
@@ -121,7 +125,7 @@ def format_result(df, input_is_df, output_is_scalar, output_multiindex):
 
 def get_idx_out(idx_in: MultiIndex, idx_weights: MultiIndex) -> MultiIndex:
     idx_all = merge_indices([idx_in, idx_weights])
-    idx_levels = dict(zip(idx_all.names, idx_all.levels))
+    idx_levels = dict(zip(idx_all.names, idx_all.levels, strict=False))
 
     idx_names_only_in = set(idx_in.names) - set(idx_weights.names)
     idx_names_only_weights = set(idx_weights.names) - set(idx_in.names)
@@ -158,8 +162,8 @@ def remap_series_to_frame(s: Series, idx: MultiIndex, colname: str) -> DataFrame
 def create_weight_map(
     ds_weights: Series, idx_in: MultiIndex, idx_out: MultiIndex
 ) -> Series:
-    """
-    Returns weight Series
+    """Returns weight Series
+
     Index is 2 dimensional (F, T), each part is a tuple from idx_in, idx_out
     for overlapping levels: left == right
 
@@ -167,8 +171,8 @@ def create_weight_map(
     idx_all = merge_indices([idx_in, idx_out])
     # expand index (TODO: check if weights are dropped??)
     df = remap_series_to_frame(ds_weights, idx_all, COL_WEIGHT)
-    df[COL_FROM] = list(zip(*[df[n] for n in idx_in.names]))
-    df[COL_TO] = list(zip(*[df[n] for n in idx_out.names]))
+    df[COL_FROM] = list(zip(*[df[n] for n in idx_in.names], strict=False))
+    df[COL_TO] = list(zip(*[df[n] for n in idx_out.names], strict=False))
 
     # filter: TODO, faster way?
     df = df.loc[df[COL_FROM].isin(idx_in)]
@@ -180,7 +184,7 @@ def create_weight_map(
     return ds_weight_map
 
 
-def validate_multiindex(item: Union[Index, Series, DataFrame]):
+def validate_multiindex(item: Index | Series | DataFrame):
     if isinstance(item, (Series, DataFrame)):
         item = item.index
     assert isinstance(item, MultiIndex)
@@ -190,13 +194,13 @@ def validate_multiindex(item: Union[Index, Series, DataFrame]):
 
 
 def transform_pandas(
-    vtype: VariableType,
-    data: Union[DataFrame, Series, float],
-    weights: Union[Index, Series, Tuple[Union[Index, Series]]],
-    dim_in: Union[Index, Series] = None,
-    dim_out: Union[Index, Series] = None,
+    vtype: type[VariableType],
+    data: DataFrame | Series | float,
+    weights: Index | Series | list[Index | Series],
+    dim_in: Index | Series | None = None,
+    dim_out: Index | Series | None = None,
     validate: bool = True,
-) -> Union[DataFrame, Series, float]:
+) -> DataFrame | Series | float:
     """(dis-)aggregate data (pandas).
 
     Parameters
@@ -244,9 +248,12 @@ def transform_pandas(
         ds_size_in = ensure_multiindex(dim_in)
         idx_in = ds_size_in.index
 
+    idx_in = cast(MultiIndex, idx_in)
+
     # determine output_index
     if dim_out is None:
-        idx_out = get_idx_out(idx_in, ds_weights.index)
+        idx_weights = cast(MultiIndex, ds_weights.index)
+        idx_out = get_idx_out(idx_in, idx_weights)
         ds_size_out = None
     elif isinstance(dim_out, Index):
         idx_out = as_multiindex(dim_out)
@@ -254,6 +261,7 @@ def transform_pandas(
     else:
         ds_size_out = ensure_multiindex(dim_out)
         idx_out = ds_size_out.index
+    idx_out = cast(MultiIndex, idx_out)
 
     if validate:
         validate_multiindex(idx_in)
@@ -263,9 +271,7 @@ def transform_pandas(
     ds_weight_map = create_weight_map(ds_weights, idx_in, idx_out)
 
     if ds_size_in is None:
-        ds_size_in = (
-            ds_weight_map.reset_index().groupby(COL_FROM).sum(COL_WEIGHT)[COL_WEIGHT]
-        )
+        ds_size_in = ds_weight_map.reset_index().groupby(COL_FROM).sum()[COL_WEIGHT]
         # fix index
         ds_size_in.index = MultiIndex.from_tuples(
             ds_size_in.index.values, names=idx_in.names
@@ -273,9 +279,7 @@ def transform_pandas(
         ds_size_in = ds_size_in.loc[ds_size_in > 0]
 
     if ds_size_out is None:
-        ds_size_out = (
-            ds_weight_map.reset_index().groupby(COL_TO).sum(COL_WEIGHT)[COL_WEIGHT]
-        )
+        ds_size_out = ds_weight_map.reset_index().groupby(COL_TO).sum()[COL_WEIGHT]
         # fix index
         ds_size_out.index = MultiIndex.from_tuples(
             ds_size_out.index.values, names=idx_out.names
@@ -291,26 +295,20 @@ def transform_pandas(
     idx_in = ds_size_in.index
     idx_out = ds_size_out.index
 
-    # apply base function
-    df_result = DataFrame(index=idx_out)
-    for name in df_data.columns:
-        s_col = df_data[name]
-        s_col = s_col.dropna()
-
-        res_col = transform(
-            vtype=vtype,
-            data=s_col,
-            weight_map=ds_weight_map,
-            weights_from=ds_size_in,
-            weights_to=ds_size_out,
-            weight_rel_threshold=0.0,
-            validate=False,  # we do validation in pandas
-        )
+    df_weight_map = ds_weight_map.unstack(level=1)
+    df_weight_map.columns = idx_out
 
-        s_res_col = Series(res_col, name=s_col.name)
-        df_result[s_col.name] = s_res_col
+    transformer = Transformer(
+        vtype=vtype,
+        df_weight_map=df_weight_map,
+        ds_weights_from=ds_size_in,
+        ds_weights_to=ds_size_out,
+        weight_rel_threshold=0,
+    )
+
+    df_result = df_data.apply(transformer)  # FIXME: why is this different
 
-    return format_result(
+    result = format_result(
         df_result,
         input_is_df=isinstance(data, DataFrame),
         output_is_scalar=idx_out.equals(IDX_SCALAR),
@@ -318,3 +316,5 @@ def transform_pandas(
             True if dim_out is None else isinstance(idx_out, MultiIndex)
         ),
     )
+
+    return result  # type:ignore