tdrpa.tdworker 1.2.13.2__py312-none-win_amd64.whl

tdrpa/_tdxlwings/pro/utils.py

@@ -0,0 +1,199 @@
+"""
+Required Notice: Copyright (C) Zoomer Analytics GmbH.
+
+xlwings PRO is dual-licensed under one of the following licenses:
+
+* PolyForm Noncommercial License 1.0.0 (for noncommercial use):
+  https://polyformproject.org/licenses/noncommercial/1.0.0
+* xlwings PRO License (for commercial use):
+  https://github.com/xlwings/xlwings/blob/main/LICENSE_PRO.txt
+
+Commercial licenses can be purchased at https://www.xlwings.org
+"""
+
+import atexit
+import base64
+import binascii
+import datetime as dt
+import glob
+import hashlib
+import hmac
+import json
+import os
+import shutil
+import tempfile
+import time
+import warnings
+from functools import lru_cache
+
+import tdrpa._tdxlwings as xlwings
+
+from ..utils import read_config_sheet
+
+try:
+    from cryptography.fernet import Fernet, InvalidToken
+except ImportError:
+    Fernet = None
+    InvalidToken = None
+
+
+class LicenseHandler:
+    @staticmethod
+    def get_cipher():
+        try:
+            return Fernet('kS2PJbJuXbNXC-sY9XFGg01OmEKuCnKAH0zyMNWWm8c=')
+        except (TypeError, ValueError):
+            raise xlwings.LicenseError(
+                "Couldn't validate xlwings license key."
+            ) from None
+
+    @staticmethod
+    def get_license():
+        # Sheet config (only used by RunPython, UDFs use env var)
+        try:
+            sheet_license_key = read_config_sheet(xlwings.Book.caller()).get(
+                "LICENSE_KEY"
+            )
+            if sheet_license_key:
+                return sheet_license_key
+        except:  # noqa: E722
+            pass
+        # User config file
+        config_file = xlwings.USER_CONFIG_FILE
+        if os.path.exists(config_file):
+            with open(config_file, "r") as f:
+                config = f.readlines()
+            key = None
+            for line in config:
+                if line.split(",")[0] == '"LICENSE_KEY"':
+                    key = line.split(",")[1].strip()[1:-1]
+            if key:
+                return key
+        # Env Var - also used if LICENSE_KEY is in config sheet and called via UDF
+        if os.getenv("XLWINGS_LICENSE_KEY"):
+            return os.environ["XLWINGS_LICENSE_KEY"]
+        raise xlwings.LicenseError("Couldn't find an xlwings license key.")
+
+    @staticmethod
+    @lru_cache()
+    def validate_license(product, license_type=None):
+        key = LicenseHandler.get_license()
+        if key == "noncommercial":
+            return {"license_type": "noncommercial"}
+        if key.startswith("gA") and not Fernet:
+            # Legacy up to 0.27.12
+            raise ImportError(
+                "You are using a legacy xlwings license key that requires the "
+                "'cryptography' package. Either install it via 'pip install "
+                "cryptography' or contact us for a new license key that doesn't depend "
+                "on cryptography."
+            ) from None
+        elif key.startswith("gA"):
+            cipher_suite = LicenseHandler.get_cipher()
+            try:
+                license_info = json.loads(cipher_suite.decrypt(key.encode()).decode())
+            except (binascii.Error, InvalidToken):
+                raise xlwings.LicenseError("Invalid xlwings license key.") from None
+        else:
+            signature = hmac.new(
+                'kS2PJbJuXbNXC-sY9XFGg01OmEKuCnKAH0zyMNWWm8c='.encode(),
+                key[:-5].encode(),
+                hashlib.sha256,
+            ).hexdigest()
+            if signature[:5] != key[-5:]:
+                raise xlwings.LicenseError("Invalid xlwings license key.") from None
+            else:
+                try:
+                    license_info = json.loads(
+                        base64.urlsafe_b64decode(key[:-5]).decode()
+                    )
+                except:  # noqa: E722
+                    raise xlwings.LicenseError("Invalid xlwings license key.") from None
+        try:
+            if (
+                license_type == "developer"
+                and license_info["license_type"] != "developer"
+            ):
+                raise xlwings.LicenseError(
+                    "You need a paid xlwings license key for this action."
+                )
+        except KeyError:
+            raise xlwings.LicenseError(
+                "You need a paid xlwings license key for this action."
+            ) from None
+        if (
+            "valid_until" not in license_info.keys()
+            or "products" not in license_info.keys()
+        ):
+            raise xlwings.LicenseError("Invalid xlwings license key format.") from None
+        license_valid_until = dt.datetime.strptime(
+            license_info["valid_until"], "%Y-%m-%d"
+        ).date()
+        if dt.date.today() > license_valid_until:
+            raise xlwings.LicenseError(
+                "Your xlwings license expired on {}.".format(
+                    license_valid_until.strftime("%Y-%m-%d")
+                )
+            ) from None
+        if product not in license_info["products"]:
+            raise xlwings.LicenseError(
+                f"Your xlwings license key isn't valid for the '{product}' "
+                "functionality."
+            ) from None
+        if (
+            "version" in license_info.keys()
+            and license_info["version"] != xlwings.__version__
+        ):
+            raise xlwings.LicenseError(
+                "Your xlwings deploy key is only valid for v{0}. To use a different "
+                "version of xlwings, re-release your tool or generate a new deploy key "
+                "via 'xlwings license deploy'.".format(license_info["version"])
+            ) from None
+        if (license_valid_until - dt.date.today()) < dt.timedelta(days=30):
+            warnings.warn(
+                f"Your xlwings license key expires in "
+                f"{(license_valid_until - dt.date.today()).days} days."
+            )
+        return license_info
+
+    @staticmethod
+    def create_deploy_key():
+        license_info = LicenseHandler.validate_license("pro", license_type="developer")
+        if license_info["license_type"] == "noncommercial":
+            return "noncommercial"
+        license_dict = json.dumps(
+            {
+                "version": xlwings.__version__,
+                "products": license_info["products"],
+                "valid_until": "2999-12-31",
+                "license_type": "deploy_key",
+            }
+        ).encode()
+        if LicenseHandler.get_license().startswith("gA"):
+            # Legacy
+            cipher_suite = LicenseHandler.get_cipher()
+            return cipher_suite.encrypt(license_dict).decode()
+        else:
+            body = base64.urlsafe_b64encode(license_dict)
+            signature = hmac.new(
+                'kS2PJbJuXbNXC-sY9XFGg01OmEKuCnKAH0zyMNWWm8c='.encode(), body, hashlib.sha256
+            ).hexdigest()
+            return f"{body.decode()}{signature[:5]}"
+
+
+@lru_cache()
+def get_embedded_code_temp_dir():
+    tmp_base_path = os.path.join(tempfile.gettempdir(), "xlwings")
+    os.makedirs(tmp_base_path, exist_ok=True)
+    try:
+        # HACK: Clean up directories that are older than 30 days
+        # This should be done in the C++ part when the Python process is killed
+        for subdir in glob.glob(tmp_base_path + "/*/"):
+            if os.path.getmtime(subdir) < time.time() - 30 * 86400:
+                shutil.rmtree(subdir, ignore_errors=True)
+    except Exception:
+        pass  # we don't care if it fails
+    tempdir = tempfile.mkdtemp(dir=tmp_base_path)
+    # This only works for RunPython calls running outside the COM server
+    atexit.register(shutil.rmtree, tempdir)
+    return tempdir

tdrpa/_tdxlwings/quickstart_fastapi/main.py

@@ -0,0 +1,47 @@
+from fastapi import Body, FastAPI, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import PlainTextResponse
+
+import tdrpa._tdxlwings as xw
+
+app = FastAPI()
+
+
+@app.post("/hello")
+def hello(data: dict = Body):
+    # Instantiate a Book object with the deserialized request body
+    with xw.Book(json=data) as book:
+        # Use xlwings as usual
+        sheet = book.sheets[0]
+        cell = sheet["A1"]
+        if cell.value == "Hello xlwings!":
+            cell.value = "Bye xlwings!"
+        else:
+            cell.value = "Hello xlwings!"
+
+        # Pass the following back as the response
+        return book.json()
+
+
+@app.exception_handler(Exception)
+async def exception_handler(request, exception):
+    # This handles all exceptions, so you may want to make this more restrictive
+    return PlainTextResponse(
+        str(exception), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+    )
+
+
+# Office Scripts and custom functions in Excel on the web require CORS
+cors_app = CORSMiddleware(
+    app=app,
+    allow_origins="*",
+    allow_methods=["POST"],
+    allow_headers=["*"],
+    allow_credentials=True,
+)
+
+
+# if __name__ == "__main__":
+#     import uvicorn
+#
+#     uvicorn.run("main:cors_app", host="127.0.0.1", port=8000, reload=True)

tdrpa/_tdxlwings/quickstart_fastapi/requirements.txt

@@ -0,0 +1,3 @@
+fastapi
+uvicorn[standard]
+xlwings

tdrpa/_tdxlwings/reports.py

@@ -0,0 +1,12 @@
+# Allows you to use xlwings.reports instead of xlwings.pro.reports
+
+from .pro.reports import *  # noqa: F401,F403
+
+__all__ = (  # noqa: F405
+    "render_template",
+    "create_report",
+    "Image",
+    "Markdown",
+    "MarkdownStyle",
+    "formatter",
+)

tdrpa/_tdxlwings/rest/__init__.py

@@ -0,0 +1 @@
+from .api import api, run  # noqa: F401

tdrpa/_tdxlwings/rest/api.py

@@ -0,0 +1,368 @@
+# See also:
+# https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/resources/excel
+# TODO: proper exception handling in xlwings base package so it can be used here
+import logging
+import sys
+
+from werkzeug.routing import PathConverter
+
+import tdrpa._tdxlwings as xw
+from tdrpa._tdxlwings.rest.serializers import (
+    serialize_app,
+    serialize_book,
+    serialize_chart,
+    serialize_name,
+    serialize_picture,
+    serialize_range,
+    serialize_shape,
+    serialize_sheet,
+)
+
+try:
+    from flask import Flask, abort, jsonify, request
+except ImportError:
+    raise Exception(
+        "To use the xlwings REST API server, you need Flask>=1.0.0 installed."
+    )
+
+
+api = Flask(__name__)
+logger = logging.getLogger(__name__)
+
+
+class EverythingConverter(PathConverter):
+    regex = ".*?"
+
+
+if sys.platform.startswith("darwin"):
+    # Hack to allow leading slashes on Mac
+    api.url_map.converters["path"] = EverythingConverter
+
+
+def get_book_object(fullname=None, name_or_ix=None, app_ix=None):
+    assert fullname is None or name_or_ix is None
+    if fullname:
+        try:
+            return xw.Book(fullname)
+        except Exception as e:
+            logger.exception(str(e))
+            abort(500, str(e))
+    elif name_or_ix:
+        if name_or_ix.isdigit():
+            name_or_ix = int(name_or_ix)
+        app = xw.apps[int(app_ix)] if app_ix else xw.apps.active
+        try:
+            return app.books[name_or_ix]
+        except KeyError as e:
+            logger.exception(str(e))
+            abort(500, "Couldn't find Book: " + str(e))
+        except Exception as e:
+            logger.exception(str(e))
+            abort(500, str(e))
+
+
+def get_sheet_object(book, name_or_id):
+    if name_or_id.isdigit():
+        name_or_id = int(name_or_id)
+    return book.sheets[name_or_id]
+
+
+@api.route("/apps", methods=["GET"])
+def get_apps():
+    return jsonify(apps=[serialize_app(app) for app in xw.apps])
+
+
+@api.route("/apps/<pid>", methods=["GET"])
+def get_app(pid):
+    return jsonify(serialize_app(xw.apps[int(pid)]))
+
+
+@api.route("/apps/<pid>/books", methods=["GET"])
+@api.route("/books", methods=["GET"])
+def get_books(pid=None):
+    books = xw.apps[int(pid)].books if pid else xw.books
+    return jsonify(books=[serialize_book(book) for book in books])
+
+
+@api.route("/apps/<pid>/books/<book_name_or_ix>", methods=["GET"])
+@api.route("/books/<book_name_or_ix>", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>", methods=["GET"])
+def get_book(book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    return jsonify(serialize_book(book))
+
+
+@api.route("/apps/<pid>/books/<book_name_or_ix>/sheets", methods=["GET"])
+@api.route("/books/<book_name_or_ix>/sheets", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>/sheets", methods=["GET"])
+def get_sheets(book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    return jsonify(sheets=[serialize_sheet(sheet) for sheet in book.sheets])
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>", methods=["GET"]
+)
+@api.route("/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>", methods=["GET"])
+def get_sheet(sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(serialize_sheet(sheet))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/range",
+    methods=["GET"],
+)
+@api.route("/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/range", methods=["GET"])
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/range", methods=["GET"]
+)
+def get_range(sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(serialize_range(sheet.used_range))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/range/<address>",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/range/<address>",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/range/<address>",
+    methods=["GET"],
+)
+def get_range_address(
+    address, sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    options = {k: v for k, v in request.args.items()}
+    return jsonify(serialize_range(sheet.range(address).options(**options)))
+
+
+@api.route("/apps/<pid>/books/<book_name_or_ix>/names", methods=["GET"])
+@api.route("/books/<book_name_or_ix>/names", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>/names", methods=["GET"])
+def get_book_names(book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    return jsonify(names=[serialize_name(name) for name in book.names])
+
+
+@api.route("/apps/<pid>/books/<book_name_or_ix>/names/<name>", methods=["GET"])
+@api.route("/books/<book_name_or_ix>/names/<name>", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>/names/<name>", methods=["GET"])
+def get_book_name(name, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    return jsonify(serialize_name(book.names[name]))
+
+
+@api.route("/apps/<pid>/books/<book_name_or_ix>/names/<name>/range", methods=["GET"])
+@api.route("/books/<book_name_or_ix>/names/<name>/range", methods=["GET"])
+@api.route("/book/<path:fullname_or_name>/names/<name>/range", methods=["GET"])
+def get_book_name_range(name, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    return jsonify(serialize_range(book.names[name].refers_to_range))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names",
+    methods=["GET"],
+)
+@api.route("/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names", methods=["GET"])
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/names", methods=["GET"]
+)
+def get_sheet_names(
+    sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(names=[serialize_name(name) for name in sheet.names])
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>",
+    methods=["GET"],
+)
+def get_sheet_name(
+    sheet_name_or_ix,
+    sheet_scope_name,
+    book_name_or_ix=None,
+    fullname_or_name=None,
+    pid=None,
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(serialize_name(sheet.names[sheet_scope_name]))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>/range",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>/range",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/names/<sheet_scope_name>/range",
+    methods=["GET"],
+)
+def get_sheet_name_range(
+    sheet_name_or_ix,
+    sheet_scope_name,
+    book_name_or_ix=None,
+    fullname_or_name=None,
+    pid=None,
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(serialize_range(sheet.names[sheet_scope_name].refers_to_range))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/charts",
+    methods=["GET"],
+)
+@api.route("/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/charts", methods=["GET"])
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/charts", methods=["GET"]
+)
+def get_charts(sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(charts=[serialize_chart(chart) for chart in sheet.charts])
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/charts/<chart_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/charts/<chart_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/charts/<chart_name_or_ix>",
+    methods=["GET"],
+)
+def get_chart(
+    sheet_name_or_ix,
+    chart_name_or_ix,
+    book_name_or_ix=None,
+    fullname_or_name=None,
+    pid=None,
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    chart = int(chart_name_or_ix) if chart_name_or_ix.isdigit() else chart_name_or_ix
+    return jsonify(serialize_chart(sheet.charts[chart]))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/shapes",
+    methods=["GET"],
+)
+@api.route("/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/shapes", methods=["GET"])
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/shapes", methods=["GET"]
+)
+def get_shapes(sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(shapes=[serialize_shape(shp) for shp in sheet.shapes])
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/shapes/<shape_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/shapes/<shape_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/shapes/<shape_name_or_ix>",
+    methods=["GET"],
+)
+def get_shape(
+    sheet_name_or_ix,
+    shape_name_or_ix,
+    book_name_or_ix=None,
+    fullname_or_name=None,
+    pid=None,
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    shape = int(shape_name_or_ix) if shape_name_or_ix.isdigit() else shape_name_or_ix
+    return jsonify(serialize_shape(sheet.shapes[shape]))
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/pictures",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/pictures", methods=["GET"]
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/pictures", methods=["GET"]
+)
+def get_pictures(
+    sheet_name_or_ix, book_name_or_ix=None, fullname_or_name=None, pid=None
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    return jsonify(pictures=[serialize_picture(pic) for pic in sheet.pictures])
+
+
+@api.route(
+    "/apps/<pid>/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/pictures/<picture_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/books/<book_name_or_ix>/sheets/<sheet_name_or_ix>/pictures/<picture_name_or_ix>",
+    methods=["GET"],
+)
+@api.route(
+    "/book/<path:fullname_or_name>/sheets/<sheet_name_or_ix>/pictures/<picture_name_or_ix>",
+    methods=["GET"],
+)
+def get_picture(
+    sheet_name_or_ix,
+    picture_name_or_ix,
+    book_name_or_ix=None,
+    fullname_or_name=None,
+    pid=None,
+):
+    book = get_book_object(fullname_or_name, book_name_or_ix, pid)
+    sheet = get_sheet_object(book, sheet_name_or_ix)
+    pic = (
+        int(picture_name_or_ix) if picture_name_or_ix.isdigit() else picture_name_or_ix
+    )
+    return jsonify(serialize_picture(sheet.pictures[pic]))
+
+
+def run(host=None, port=None, debug=None, **options):
+    """
+    Run Flask development server
+    """
+    api.run(host=host, port=port, debug=debug, **options)
+
+
+if __name__ == "__main__":
+    run(debug=True)