tdrpa.tdworker 1.1.9.3__py39-none-win_amd64.whl

tdrpa/_tdxlwings/conversion/__init__.py

@@ -0,0 +1,103 @@
+try:
+    import pandas as pd
+except ImportError:
+    pd = None
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+from .framework import (
+    Accessor,
+    ConversionContext,
+    Converter,
+    Options,
+    Pipeline,
+    accessors,
+)
+from .standard import (
+    AdjustDimensionsStage,
+    CleanDataForWriteStage,
+    CleanDataFromReadStage,
+    DictConverter,
+    Ensure2DStage,
+    ExpandRangeStage,
+    RangeAccessor,
+    RawValueAccessor,
+    ReadValueFromRangeStage,
+    TransposeStage,
+    ValueAccessor,
+    WriteValueToRangeStage,
+)
+
+if np:
+    from .numpy_conv import NumpyArrayConverter
+if pd:
+    from .pandas_conv import PandasDataFrameConverter, PandasSeriesConverter
+
+from .. import LicenseError
+
+try:
+    from ..pro.reports.markdown import Markdown, MarkdownConverter
+
+    MarkdownConverter.register(Markdown)
+except (ImportError, LicenseError, AttributeError):
+    pass
+
+
+__all__ = (
+    "Accessor",
+    "ConversionContext",
+    "Converter",
+    "Options",
+    "Pipeline",
+    "accessors",
+    "AdjustDimensionsStage",
+    "CleanDataForWriteStage",
+    "CleanDataFromReadStage",
+    "DictConverter",
+    "Ensure2DStage",
+    "ExpandRangeStage",
+    "RangeAccessor",
+    "RawValueAccessor",
+    "ReadValueFromRangeStage",
+    "TransposeStage",
+    "ValueAccessor",
+    "WriteValueToRangeStage",
+    "NumpyArrayConverter",
+    "PandasDataFrameConverter",
+    "PandasSeriesConverter",
+)
+
+
+def read(rng, value, options, engine_name=None):
+    convert = options.get("convert", None)
+    pipeline = accessors.get(convert, convert).reader(options)
+    ctx = ConversionContext(rng=rng, value=value, engine_name=engine_name)
+    pipeline(ctx)
+    return ctx.value
+
+
+def write(value, rng, options, engine_name=None):
+    # Don't allow to write lists and tuples as jagged arrays as appscript and pywin32
+    # don't handle that properly. This should really be handled in Ensure2DStage, but
+    # we'd have to set the original format in the conversion ctx meta as the check
+    # should only run for list and tuples.
+    if (
+        isinstance(value, (list, tuple))
+        and len(value) > 0
+        and isinstance(value[0], (list, tuple))
+    ):
+        first_row = value[0]
+        for row in value:
+            if len(first_row) != len(row):
+                raise Exception(
+                    "All elements of a 2d list or tuple must be of the same length"
+                )
+    convert = options.get("convert", None)
+    pipeline = (
+        accessors.get(convert, convert).router(value, rng, options).writer(options)
+    )
+    ctx = ConversionContext(rng=rng, value=value, engine_name=engine_name)
+    pipeline(ctx)
+    return ctx.value

tdrpa/_tdxlwings/conversion/framework.py

@@ -0,0 +1,147 @@
+import tdrpa._tdxlwings as xlwings
+
+class ConversionContext:
+    __slots__ = ["range", "value", "source_value", "meta", "engine"]
+
+    def __init__(self, rng=None, value=None, engine_name=None):
+        self.range = rng
+        if engine_name:
+            self.engine = xlwings.engines[engine_name]
+        else:
+            # rng can only be None if used via COM server UDFs
+            self.engine = rng.sheet.book.app.engine if rng else xlwings.engines["excel"]
+        self.value = value
+        # used for markdown (could be replaced by handing the parsed ast from
+        # the converter stage to the formatting stage
+        self.source_value = value
+        self.meta = {}
+
+
+class Options(dict):
+    def __init__(self, original):
+        super(Options, self).__init__(original)
+
+    def override(self, **overrides):
+        self.update(overrides)
+        return self
+
+    def erase(self, keys):
+        for key in keys:
+            self.pop(key, None)
+        return self
+
+    def defaults(self, **defaults):
+        for k, v in defaults.items():
+            self.setdefault(k, v)
+        return self
+
+
+class Pipeline(list):
+    def prepend_stage(self, stage, only_if=True):
+        if only_if:
+            self.insert(0, stage)
+        return self
+
+    def append_stage(self, stage, only_if=True):
+        if only_if:
+            self.append(stage)
+        return self
+
+    def insert_stage(
+        self, stage, index=None, after=None, before=None, replace=None, only_if=True
+    ):
+        if only_if:
+            if sum(x is not None for x in (index, after, before, replace)) != 1:
+                raise ValueError(
+                    "Must specify exactly one of arguments: "
+                    "index, after, before, replace"
+                )
+            if index is not None:
+                indices = (index,)
+            elif after is not None:
+                indices = tuple(
+                    i + 1 for i, x in enumerate(self) if isinstance(x, after)
+                )
+            elif before is not None:
+                indices = tuple(i for i, x in enumerate(self) if isinstance(x, before))
+            elif replace is not None:
+                for i, x in enumerate(self):
+                    if isinstance(x, replace):
+                        self[i] = stage
+                return self
+            for i in reversed(indices):
+                self.insert(i, stage)
+        return self
+
+    def __call__(self, *args, **kwargs):
+        for stage in self:
+            stage(*args, **kwargs)
+
+
+accessors = {}
+
+
+class Accessor:
+    @classmethod
+    def reader(cls, options):
+        return Pipeline()
+
+    @classmethod
+    def writer(cls, options):
+        return Pipeline()
+
+    @classmethod
+    def register(cls, *types):
+        for type in types:
+            accessors[type] = cls
+
+    @classmethod
+    def router(cls, value, rng, options):
+        return cls
+
+
+class Converter(Accessor):
+    class ToValueStage:
+        def __init__(self, write_value, options):
+            self.write_value = write_value
+            self.options = options
+
+        def __call__(self, c):
+            c.value = self.write_value(c.value, self.options)
+
+    class FromValueStage:
+        def __init__(self, read_value, options):
+            self.read_value = read_value
+            self.options = options
+
+        def __call__(self, c):
+            c.value = self.read_value(c.value, self.options)
+
+    base_type = None
+    base = None
+
+    @classmethod
+    def base_reader(cls, options, base_type=None):
+        if cls.base is not None:
+            return cls.base.reader(options)
+        else:
+            return accessors[base_type or cls.base_type].reader(options)
+
+    @classmethod
+    def base_writer(cls, options, base_type=None):
+        if cls.base is not None:
+            return cls.base.writer(options)
+        else:
+            return accessors[base_type or cls.base_type].writer(options)
+
+    @classmethod
+    def reader(cls, options):
+        return cls.base_reader(options).append_stage(
+            cls.FromValueStage(cls.read_value, options)
+        )
+
+    @classmethod
+    def writer(cls, options):
+        return cls.base_writer(options).prepend_stage(
+            cls.ToValueStage(cls.write_value, options)
+        )

tdrpa/_tdxlwings/conversion/numpy_conv.py

@@ -0,0 +1,34 @@
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+if np:
+    try:
+        import pandas as pd
+    except ImportError:
+        pd = None
+
+    from . import Converter, Options
+
+    class NumpyArrayConverter(Converter):
+        @classmethod
+        def base_reader(cls, options):
+            return super(NumpyArrayConverter, cls).base_reader(
+                Options(options).defaults(empty=np.nan)
+            )
+
+        @classmethod
+        def read_value(cls, value, options):
+            dtype = options.get("dtype", None)
+            copy = options.get("copy", True)
+            order = options.get("order", None)
+            ndim = options.get("ndim", None) or 0
+            return np.array(value, dtype=dtype, copy=copy, order=order, ndmin=ndim)
+
+        @classmethod
+        def write_value(cls, value, options):
+            return value.tolist()
+
+    NumpyArrayConverter.register(np.array, np.ndarray)

tdrpa/_tdxlwings/conversion/pandas_conv.py

@@ -0,0 +1,184 @@
+from ..utils import xlserial_to_datetime
+
+try:
+    import pandas as pd
+except ImportError:
+    pd = None
+
+
+if pd:
+    from . import Converter, Options
+
+    def _parse_dates(df, parse_dates):
+        # Office.js UDFs don't have the info whether the cell is in date format
+        if parse_dates is True:
+            parse_dates = [0]
+        elif not isinstance(parse_dates, list):
+            parse_dates = [parse_dates]
+        for col in parse_dates:
+            if isinstance(col, str):
+                df.loc[:, col] = df.loc[:, col].apply(xlserial_to_datetime)
+            else:
+                df.iloc[:, col] = df.iloc[:, col].apply(xlserial_to_datetime)
+        return df
+
+    def write_value(cls, value, options):
+        index = options.get("index", True)
+        header = options.get("header", True)
+        assign_empty_index_names = options.get("assign_empty_index_names", False)
+
+        index_names = value.index.names
+        if assign_empty_index_names:
+            # Useful when you want to have your DataFrame formatted as an Excel table
+            # which requires column header names. Since Excel tables only allow an empty
+            # space once, we'll generate multiple empty spaces for each column.
+            index_names = [
+                " " * (i + 1) if name is None else name
+                for i, name in enumerate(index_names)
+            ]
+        else:
+            index_names = ["" if name is None else name for name in index_names]
+        index_levels = len(index_names)
+
+        if index:
+            if value.index.name in value.columns:
+                # Prevents column name collision when resetting the index
+                value.index = value.index.rename(None)
+            value = value.reset_index()
+
+        # Convert pandas-specific types without corresponding Excel type to strings
+        for ix, col in enumerate(value.columns):
+            if (
+                isinstance(value.iloc[:, ix].dtype, pd.PeriodDtype)
+                or value.iloc[:, ix].dtype == "timedelta64[ns]"
+            ):
+                value.iloc[:, ix] = value.iloc[:, ix].astype(str)
+
+        if header:
+            if isinstance(value.columns, pd.MultiIndex):
+                columns = list(zip(*value.columns.tolist()))
+                columns = [list(i) for i in columns]
+                # Move index names right above the index
+                if index:
+                    for c in columns[:-1]:
+                        c[:index_levels] = [""] * index_levels
+                    columns[-1][:index_levels] = index_names
+            else:
+                columns = [value.columns.tolist()]
+                if index:
+                    columns[0][:index_levels] = index_names
+            value = columns + value.values.tolist()
+        else:
+            value = value.values.tolist()
+
+        return value
+
+    class PandasDataFrameConverter(Converter):
+        @classmethod
+        def base_reader(cls, options):
+            return super(PandasDataFrameConverter, cls).base_reader(
+                Options(options).override(ndim=2)
+            )
+
+        @classmethod
+        def read_value(cls, value, options):
+            index = options.get("index", 1)
+            header = options.get("header", 1)
+            dtype = options.get("dtype", None)
+            copy = options.get("copy", False)
+            parse_dates = options.get("parse_dates", None)
+
+            # build dataframe with only columns (no index) but correct header
+            if header == 1:
+                columns = pd.Index(value[0])
+            elif header > 1:
+                columns = pd.MultiIndex.from_arrays(value[:header])
+            else:
+                columns = None
+
+            df = pd.DataFrame(value[header:], columns=columns, dtype=dtype, copy=copy)
+
+            if parse_dates:
+                df = _parse_dates(df, parse_dates)
+
+            # handle index by resetting the index to the index first columns
+            # and renaming the index according to the name in the last row
+            if index > 0:
+                # rename uniquely the index columns to some never used name for column
+                # we do not use the column name directly as it would cause issues if
+                # several columns have the same name
+                df.columns = pd.Index(range(len(df.columns)))
+                df = df.set_index(list(df.columns)[:index])
+
+                df.index.names = pd.Index(
+                    value[header - 1][:index] if header else [None] * index
+                )
+
+                if header:
+                    df.columns = columns[index:]
+                else:
+                    df.columns = pd.Index(range(len(df.columns)))
+
+            return df
+
+        @classmethod
+        def write_value(cls, value, options):
+            return write_value(cls, value, options)
+
+    PandasDataFrameConverter.register(pd.DataFrame, "df")
+
+    class PandasSeriesConverter(Converter):
+        @classmethod
+        def read_value(cls, value, options):
+            index = options.get("index", 1)
+            header = options.get("header", True)
+            dtype = options.get("dtype", None)
+            copy = options.get("copy", False)
+            parse_dates = options.get("parse_dates", None)
+
+            if header:
+                columns = value[0]
+                if not isinstance(columns, list):
+                    columns = [columns]
+                data = value[1:]
+            else:
+                columns = None
+                data = value
+
+            df = pd.DataFrame(data, columns=columns, dtype=dtype, copy=copy)
+
+            if parse_dates:
+                df = _parse_dates(df, parse_dates)
+
+            if index:
+                df.columns = pd.Index(range(len(df.columns)))
+                df = df.set_index(list(df.columns)[:index])
+                df.index.names = pd.Index(
+                    value[header - 1][:index] if header else [None] * index
+                )
+
+            if header:
+                df.columns = columns[index:]
+            else:
+                df.columns = pd.Index(range(len(df.columns)))
+
+            series = df.squeeze()
+
+            if not header:
+                series.name = None
+                series.index.name = None
+
+            return series
+
+        @classmethod
+        def write_value(cls, value, options):
+            if all(v is None for v in value.index.names) and value.name is None:
+                default_header = False
+            else:
+                default_header = True
+
+            options["header"] = options.get("header", default_header)
+            values = write_value(cls, value.to_frame(), options)
+            return values
+
+    PandasSeriesConverter.register(pd.Series)