tdrpa.tdworker 1.2.13.2__py312-none-win_amd64.whl

tdrpa/_tdxlwings/conversion/standard.py

@@ -0,0 +1,321 @@
+import datetime
+import math
+from collections import OrderedDict
+
+from .. import LicenseError
+from ..main import Range
+from ..utils import chunk, xlserial_to_datetime
+from . import Accessor, Converter, Options, Pipeline, accessors
+
+try:
+    from ..pro import Markdown
+    from ..pro.reports import markdown
+except (ImportError, LicenseError, AttributeError):
+    Markdown = None
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+_date_handlers = {
+    datetime.datetime: datetime.datetime,
+    datetime.date: lambda year, month, day, **kwargs: datetime.date(year, month, day),
+}
+
+_number_handlers = {
+    int: lambda x: int(round(x)),
+    "raw int": int,
+}
+
+
+class ExpandRangeStage:
+    def __init__(self, options):
+        self.expand = options.get("expand", None)
+
+    def __call__(self, c):
+        if c.range:
+            # auto-expand the range
+            if self.expand:
+                c.range = c.range.expand(self.expand)
+
+
+class WriteValueToRangeStage:
+    def __init__(self, options, raw=False):
+        self.raw = raw
+        self.options = options
+
+    def _write_value(self, rng, value, scalar):
+        if rng.api and value:
+            # it is assumed by this stage that value is a list of lists
+            if scalar:
+                value = value[0][0]
+            else:
+                rng = rng.resize(len(value), len(value[0]))
+
+            chunksize = self.options.get("chunksize")
+            if chunksize:
+                for ix, value_chunk in enumerate(chunk(value, chunksize)):
+                    rng[
+                        ix * chunksize : ix * chunksize + chunksize, :
+                    ].raw_value = value_chunk
+            else:
+                rng.raw_value = value
+
+    def __call__(self, ctx):
+        if ctx.range and ctx.value:
+            if self.raw:
+                ctx.range.raw_value = ctx.value
+                return
+
+            scalar = ctx.meta.get("scalar", False)
+            if not scalar:
+                ctx.range = ctx.range.resize(len(ctx.value), len(ctx.value[0]))
+
+            self._write_value(ctx.range, ctx.value, scalar)
+
+
+class ReadValueFromRangeStage:
+    def __init__(self, options):
+        self.options = options
+
+    def __call__(self, c):
+        chunksize = self.options.get("chunksize")
+        if c.range and chunksize:
+            parts = []
+            for i in range(math.ceil(c.range.shape[0] / chunksize)):
+                raw_value = c.range[
+                    i * chunksize : (i * chunksize) + chunksize, :
+                ].raw_value
+                if isinstance(raw_value[0], (list, tuple)):
+                    parts.extend(raw_value)
+                else:
+                    # Turn a single row list into a 2d list
+                    parts.extend([raw_value])
+
+            c.value = parts
+        elif c.range:
+            c.value = c.range.raw_value
+
+
+class CleanDataFromReadStage:
+    def __init__(self, options):
+        self.options = options
+        dates_as = options.get("dates", datetime.datetime)
+        self.empty_as = options.get("empty", None)
+        self.dates_handler = _date_handlers.get(dates_as, dates_as)
+        numbers_as = options.get("numbers", None)
+        self.numbers_handler = _number_handlers.get(numbers_as, numbers_as)
+        self.err_to_str = options.get("err_to_str", False)
+
+    def __call__(self, c):
+        c.value = c.engine.impl.clean_value_data(
+            c.value,
+            self.dates_handler,
+            self.empty_as,
+            self.numbers_handler,
+            self.err_to_str,
+        )
+
+
+class CleanDataForWriteStage:
+    def __init__(self, options):
+        self.options = options
+
+    def __call__(self, c):
+        c.value = [
+            [c.engine.impl.prepare_xl_data_element(x, self.options) for x in y]
+            for y in c.value
+        ]
+
+
+class AdjustDimensionsStage:
+    def __init__(self, options):
+        self.ndim = options.get("ndim", None)
+
+    def __call__(self, c):
+        # the assumption is that value is 2-dimensional at this stage
+
+        if self.ndim is None:
+            if len(c.value) == 1:
+                c.value = c.value[0][0] if len(c.value[0]) == 1 else c.value[0]
+            elif len(c.value[0]) == 1:
+                c.value = [x[0] for x in c.value]
+            else:
+                c.value = c.value
+
+        elif self.ndim == 1:
+            if len(c.value) == 1:
+                c.value = c.value[0]
+            elif len(c.value[0]) == 1:
+                c.value = [x[0] for x in c.value]
+            else:
+                raise Exception("Range must be 1-by-n or n-by-1 when ndim=1.")
+
+        # ndim = 2 is a no-op
+        elif self.ndim != 2:
+            raise ValueError("Invalid c.value ndim=%s" % self.ndim)
+
+
+class Ensure2DStage:
+    def __call__(self, c):
+        if isinstance(c.value, (list, tuple)):
+            if len(c.value) > 0:
+                if not isinstance(c.value[0], (list, tuple)):
+                    c.value = [c.value]
+        else:
+            c.meta["scalar"] = True
+            c.value = [[c.value]]
+
+
+class TransposeStage:
+    def __call__(self, c):
+        c.value = [
+            [e[i] for e in c.value] for i in range(len(c.value[0]) if c.value else 0)
+        ]
+
+
+class FormatStage:
+    def __init__(self, options):
+        self.options = options
+
+    def __call__(self, ctx):
+        if Markdown and isinstance(ctx.source_value, Markdown):
+            markdown.format_text(
+                ctx.range, ctx.source_value.text, ctx.source_value.style
+            )
+        if "formatter" in self.options:
+            self.options["formatter"](ctx.range, ctx.source_value)
+
+
+class BaseAccessor(Accessor):
+    @classmethod
+    def reader(cls, options):
+        return Pipeline().append_stage(
+            ExpandRangeStage(options), only_if=options.get("expand", None)
+        )
+
+
+class RangeAccessor(Accessor):
+    @staticmethod
+    def copy_range_to_value(c):
+        c.value = c.range
+
+    @classmethod
+    def reader(cls, options):
+        return BaseAccessor.reader(options).append_stage(
+            RangeAccessor.copy_range_to_value
+        )
+
+
+RangeAccessor.register("range", Range)
+
+
+class RawValueAccessor(Accessor):
+    @classmethod
+    def reader(cls, options):
+        return Accessor.reader(options).append_stage(ReadValueFromRangeStage(options))
+
+    @classmethod
+    def writer(cls, options):
+        return Accessor.writer(options).prepend_stage(
+            WriteValueToRangeStage(options, raw=True)
+        )
+
+
+RawValueAccessor.register("raw")
+
+
+class ValueAccessor(Accessor):
+    @staticmethod
+    def reader(options):
+        return (
+            BaseAccessor.reader(options)
+            .append_stage(ReadValueFromRangeStage(options))
+            .append_stage(Ensure2DStage())
+            .append_stage(CleanDataFromReadStage(options))
+            .append_stage(TransposeStage(), only_if=options.get("transpose", False))
+            .append_stage(AdjustDimensionsStage(options))
+        )
+
+    @staticmethod
+    def writer(options):
+        return (
+            Pipeline()
+            .prepend_stage(FormatStage(options))
+            .prepend_stage(WriteValueToRangeStage(options))
+            .prepend_stage(CleanDataForWriteStage(options))
+            .prepend_stage(TransposeStage(), only_if=options.get("transpose", False))
+            .prepend_stage(Ensure2DStage())
+        )
+
+    @classmethod
+    def router(cls, value, rng, options):
+        return accessors.get(type(value), cls)
+
+
+ValueAccessor.register(None)
+
+
+class DictConverter(Converter):
+    @classmethod
+    def base_reader(cls, options):
+        return super(DictConverter, cls).base_reader(Options(options).override(ndim=2))
+
+    @classmethod
+    def read_value(cls, value, options):
+        assert not value or len(value[0]) == 2
+        return dict(value)
+
+    @classmethod
+    def write_value(cls, value, options):
+        return list(value.items())
+
+
+DictConverter.register(dict)
+
+
+class OrderedDictConverter(Converter):
+    @classmethod
+    def base_reader(cls, options):
+        return super(OrderedDictConverter, cls).base_reader(
+            Options(options).override(ndim=2)
+        )
+
+    @classmethod
+    def read_value(cls, value, options):
+        assert not value or len(value[0]) == 2
+        return OrderedDict(value)
+
+    @classmethod
+    def write_value(cls, value, options):
+        return list(value.items())
+
+
+OrderedDictConverter.register(OrderedDict)
+
+
+class DatetimeConverter(Converter):
+    @classmethod
+    def read_value(cls, value, options):
+        return xlserial_to_datetime(value)
+
+    @classmethod
+    def write_value(cls, value, options):
+        return value
+
+
+DatetimeConverter.register(datetime.datetime)
+
+
+class DateConverter(Converter):
+    @classmethod
+    def read_value(cls, value, options):
+        return xlserial_to_datetime(value).date()
+
+    @classmethod
+    def write_value(cls, value, options):
+        return value
+
+
+DateConverter.register(datetime.date)

tdrpa/_tdxlwings/expansion.py

@@ -0,0 +1,83 @@
+from .main import Range
+
+expanders = {}
+
+_empty = (None, "", [[""]], [[None]], [("",)], [(None,)])
+
+
+class Expander:
+    def register(self, *aliases):
+        for alias in aliases:
+            expanders[alias] = self
+
+    def expand(self, rng):
+        """
+        Expands a range
+
+        Arguments
+        ---------
+        rng: Range
+            The reference range
+
+        Returns
+        -------
+        Range object: The expanded range
+
+        """
+        raise NotImplementedError()
+
+
+class TableExpander(Expander):
+    def expand(self, rng):
+        origin = rng(1, 1)
+
+        if origin.has_array:
+            bottom_left = origin.end("down")
+        elif origin(2, 1).raw_value in _empty:
+            bottom_left = origin
+        elif origin(3, 1).raw_value in _empty:
+            bottom_left = origin(2, 1)
+        else:
+            bottom_left = origin(2, 1).end("down")
+
+        if origin.has_array:
+            top_right = origin.end("right")
+        elif origin(1, 2).raw_value in _empty:
+            top_right = origin
+        elif origin(1, 3).raw_value in _empty:
+            top_right = origin(1, 2)
+        else:
+            top_right = origin(1, 2).end("right")
+
+        return Range(top_right, bottom_left)
+
+
+TableExpander().register("table")
+
+
+class VerticalExpander(Expander):
+    def expand(self, rng):
+        if rng(2, 1).raw_value in _empty:
+            return Range(rng(1, 1), rng(1, rng.shape[1]))
+        elif rng(3, 1).raw_value in _empty:
+            return Range(rng(1, 1), rng(2, rng.shape[1]))
+        else:
+            end_row = rng(2, 1).end("down").row - rng.row + 1
+            return Range(rng(1, 1), rng(end_row, rng.shape[1]))
+
+
+VerticalExpander().register("vertical", "down", "d")
+
+
+class HorizontalExpander(Expander):
+    def expand(self, rng):
+        if rng(1, 2).raw_value in _empty:
+            return Range(rng(1, 1), rng(rng.shape[0], 1))
+        elif rng(1, 3).raw_value in _empty:
+            return Range(rng(1, 1), rng(rng.shape[0], 2))
+        else:
+            end_column = rng(1, 2).end("right").column - rng.column + 1
+        return Range(rng(1, 1), rng(rng.shape[0], end_column))
+
+
+HorizontalExpander().register("horizontal", "right", "r")

tdrpa/_tdxlwings/ext/__init__.py

@@ -0,0 +1,3 @@
+from .sql import sql, sql_dynamic
+
+__all__ = "sql", "sql_dynamic"

tdrpa/_tdxlwings/ext/sql.py

@@ -0,0 +1,73 @@
+import sqlite3
+
+from .. import arg, func, ret
+
+
+def conv_value(value, col_is_str):
+    if value is None:
+        return "NULL"
+    if col_is_str:
+        return repr(str(value))
+    elif isinstance(value, bool):
+        return 1 if value else 0
+    else:
+        return repr(value)
+
+
+@func
+@arg("tables", expand="table", ndim=2)
+@ret(expand="table")
+def sql(query, *tables):
+    return _sql(query, *tables)
+
+
+@func
+@arg("tables", expand="table", ndim=2)
+def sql_dynamic(query, *tables):
+    """Called if native dynamic arrays are available"""
+    return _sql(query, *tables)
+
+
+def _sql(query, *tables):
+    conn = sqlite3.connect(":memory:")
+
+    c = conn.cursor()
+
+    for i, table in enumerate(tables):
+        cols = table[0]
+        rows = table[1:]
+        types = [any(isinstance(row[j], str) for row in rows) for j in range(len(cols))]
+        name = chr(65 + i)
+
+        stmt = "CREATE TABLE %s (%s)" % (
+            name,
+            ", ".join(
+                "'%s' %s" % (col, "STRING" if typ else "REAL")
+                for col, typ in zip(cols, types)
+            ),
+        )
+        c.execute(stmt)
+
+        if rows:
+            stmt = "INSERT INTO %s VALUES %s" % (
+                name,
+                ", ".join(
+                    "(%s)"
+                    % ", ".join(
+                        conv_value(value, type) for value, typ in zip(row, types)
+                    )
+                    for row in rows
+                ),
+            )
+            # Fixes values like these:
+            # sql('SELECT a FROM a', [['a', 'b'], ["""X"Y'Z""", 'd']])
+            stmt = stmt.replace("\\'", "''")
+            c.execute(stmt)
+
+    res = []
+    c.execute(query)
+    res.append([x[0] for x in c.description])
+    for row in c:
+        res.append(list(row))
+
+    return res

tdrpa/_tdxlwings/html/xlwings-alert.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<!-- 
+Copyright (C) 2014 - present, Zoomer Analytics GmbH. All rights reserved.
+Licensed under BSD-3-Clause license, see: https://docs.xlwings.org/en/stable/license.html
+
+This file also contains code from Bootstrap
+Copyright (c) 2011-2023 The Bootstrap Authors, Licensed under MIT license, see https://raw.githubusercontent.com/twbs/bootstrap/main/LICENSE
+
+This file also contains code from bootstrap-ie11
+Copyright (c) 2022 Christian Oliff, Licensed under MIT license, see https://raw.githubusercontent.com/coliff/bootstrap-ie11/main/LICENSE
+ -->
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Alert</title>
+  <script src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+  <link rel="stylesheet"
+    href="https://cdn.jsdelivr.net/gh/xlwings/bootstrap-xlwings@5.2.3-2/dist/bootstrap-xlwings.min.css"
+    integrity="sha384-TZ8CaOSXLBEEL73Aw1vX6a/2YP7QHdiuilF2C8Put8X81F3FzyRgt9ba77CMKAXq" crossorigin="anonymous">
+  <script
+    nomodule>window.MSInputMethodContext && document.documentMode && document.write('<link rel="stylesheet" href="/css/bootstrap-ie11.min.css"><script src="https://cdn.jsdelivr.net/combine/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js,npm/ie11-custom-properties@4,npm/element-qsa-scope@1"><\/script><script crossorigin="anonymous" src="https://polyfill.io/v3/polyfill.min.js?features=default%2CNumber.parseInt%2CNumber.parseFloat%2CArray.prototype.find%2CArray.prototype.includes"><\/script>');</script>
+</head>
+
+<body>
+  <div id="callback" data-callback="{{ callback }}"></div>
+  <div class="container-fluid">
+    <div class="d-flex flex-column pb-3 px-2 vh-100">
+      <h1 class="pt-4">{{ title }}</h1>
+      <p>{{ prompt|replace("\n", "<br>"|safe) }}</p>
+      <div class="mt-auto">
+        <div class="float-end">
+          {% if "ok" in buttons %}
+          <button id="ok" type="button" class="btn btn-primary btn-xl-alert">OK</button>
+          {% endif %}
+          {% if "yes" in buttons %}
+          <button id="yes" type="button" class="btn btn-primary btn-xl-alert">Yes</button>
+          {% endif %}
+          {% if "no" in buttons %}
+          <button id="no" type="button" class="btn btn-outline-secondary btn-xl-alert">No</button>
+          {% endif %}
+          {% if "cancel" in buttons %}
+          <button id="cancel" type="button" class="btn btn-outline-secondary btn-xl-alert">Cancel</button>
+          {% endif %}
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    Office.onReady(function (info) { });
+    if (document.getElementById("ok")) {
+      document.getElementById("ok").addEventListener("click", buttonCallback);
+    }
+    if (document.getElementById("yes")) {
+      document.getElementById("yes").addEventListener("click", buttonCallback);
+    }
+    if (document.getElementById("no")) {
+      document.getElementById("no").addEventListener("click", buttonCallback);
+    }
+    if (document.getElementById("cancel")) {
+      document.getElementById("cancel").addEventListener("click", buttonCallback);
+    }
+    function buttonCallback() {
+      Office.context.ui.messageParent(this.id + "|" + document.getElementById("callback").getAttribute("data-callback"));
+    }
+  </script>
+</body>
+
+</html>