tdrpa.tdworker 1.2.13.2__py312-none-win_amd64.whl

tdrpa/_tdxlwings/_xlmac.py

@@ -0,0 +1,2240 @@
+import atexit
+import datetime as dt
+import os
+import re
+import shutil
+import struct
+import subprocess
+from pathlib import Path
+
+import aem
+import appscript
+import osax
+import psutil
+from appscript import its, k as kw, mactypes
+from appscript.reference import CommandError
+
+import tdrpa._tdxlwings as xlwings
+
+from . import base_classes, mac_dict, utils
+from .constants import ColorIndex
+from .utils import (
+    VersionNumber,
+    col_name,
+    fullname_url_to_local_path,
+    int_to_rgb,
+    np_datetime_to_datetime,
+    read_config_sheet,
+)
+
+try:
+    import pandas as pd
+except ImportError:
+    pd = None
+try:
+    import numpy as np
+except ImportError:
+    np = None
+try:
+    from PIL import ImageGrab
+except ImportError:
+    PIL = None
+
+
+# Time types
+time_types = (dt.date, dt.datetime)
+if np:
+    time_types = time_types + (np.datetime64,)
+
+cell_errors = (
+    "#DIV/0!",
+    "#N/A",
+    "#NAME?",
+    "#NULL!",
+    "#NUM!",
+    "#REF!",
+    "#VALUE!",
+)
+
+
+def _clean_value_data_element(
+    value, datetime_builder, empty_as, number_builder, err_to_str
+):
+    if value == "" or value == kw.missing_value:
+        return empty_as
+    if isinstance(value, dt.datetime) and datetime_builder is not dt.datetime:
+        value = datetime_builder(
+            month=value.month,
+            day=value.day,
+            year=value.year,
+            hour=value.hour,
+            minute=value.minute,
+            second=value.second,
+            microsecond=value.microsecond,
+            tzinfo=None,
+        )
+    elif number_builder is not None and isinstance(value, float):
+        value = number_builder(value)
+    return value
+
+
+class Engine:
+    @property
+    def apps(self):
+        return Apps()
+
+    @property
+    def name(self):
+        return "excel"
+
+    @property
+    def type(self):
+        return "desktop"
+
+    @staticmethod
+    def prepare_xl_data_element(x, options):
+        if x is None:
+            return ""
+        elif pd and pd.isna(x):
+            return ""
+        elif np and isinstance(x, (np.floating, float)) and np.isnan(x):
+            return ""
+        elif np and isinstance(x, np.datetime64):
+            # handle numpy.datetime64
+            return np_datetime_to_datetime(x).replace(tzinfo=None)
+        elif np and isinstance(x, np.number):
+            return float(x)
+        elif pd and isinstance(x, pd.Timestamp):
+            # This transformation seems to be only needed on Python 2.6 (?)
+            return x.to_pydatetime().replace(tzinfo=None)
+        elif pd and isinstance(x, type(pd.NaT)):
+            return None
+        elif isinstance(x, dt.datetime):
+            # Make datetime timezone naive
+            return x.replace(tzinfo=None)
+        elif isinstance(x, bool):
+            # Must be tested before int!
+            return x
+        elif isinstance(x, int):
+            # appscript packs integers larger than SInt32 but smaller than SInt64 as
+            # typeSInt64, and integers larger than SInt64 as typeIEEE64BitFloatingPoint.
+            # Excel silently ignores typeSInt64. (GH 227)
+            return float(x)
+        return x
+
+    @staticmethod
+    def clean_value_data(data, datetime_builder, empty_as, number_builder, err_to_str):
+        return [
+            [
+                _clean_value_data_element(
+                    c, datetime_builder, empty_as, number_builder, err_to_str
+                )
+                for c in row
+            ]
+            for row in data
+        ]
+
+
+engine = Engine()
+
+
+class Apps(base_classes.Apps):
+    def _iter_excel_instances(self):
+        asn = subprocess.check_output(
+            ["lsappinfo", "visibleprocesslist", "-includehidden"]
+        ).decode("utf-8")
+        for asn in asn.split(" "):
+            if "Microsoft_Excel" in asn:
+                pid_info = subprocess.check_output(
+                    ["lsappinfo", "info", "-only", "pid", asn]
+                ).decode("utf-8")
+                if pid_info != '"pid"=[ NULL ] \n':
+                    yield int(pid_info.split("=")[1])
+
+    def keys(self):
+        return list(self._iter_excel_instances())
+
+    def add(self, spec=None, add_book=None, visible=None):
+        return App(spec=spec, add_book=add_book, visible=visible)
+
+    def __iter__(self):
+        for pid in self._iter_excel_instances():
+            yield App(xl=pid)
+
+    def __len__(self):
+        return len(list(self._iter_excel_instances()))
+
+    def __getitem__(self, pid):
+        if pid not in self.keys():
+            raise KeyError("Could not find an Excel instance with this PID.")
+        return App(xl=pid)
+
+
+class App(base_classes.App):
+    def __init__(self, spec=None, add_book=None, xl=None, visible=True):
+        if xl is None:
+            self._xl = appscript.app(
+                name=spec or "Microsoft Excel",
+                newinstance=True,
+                terms=mac_dict,
+                hide=not visible,
+            )
+            if visible:
+                self.activate()  # Makes it behave like on Windows
+        elif isinstance(xl, int):
+            self._xl = appscript.app(pid=xl, terms=mac_dict)
+        else:
+            self._xl = xl
+
+    @property
+    def xl(self):
+        return self._xl
+
+    @xl.setter
+    def xl(self, value):
+        self._xl = value
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def engine(self):
+        return engine
+
+    @property
+    def path(self):
+        return hfs_to_posix_path(self.xl.path.get())
+
+    @property
+    def pid(self):
+        data = (
+            self.xl.AS_appdata.target()
+            .addressdesc.coerce(aem.kae.typeKernelProcessID)
+            .data
+        )
+        (pid,) = struct.unpack("i", data)
+        return pid
+
+    @property
+    def version(self):
+        return self.xl.version.get()
+
+    @property
+    def selection(self):
+        sheet = self.books.active.sheets.active
+        try:
+            # fails if e.g. chart is selected
+            return Range(sheet, self.xl.selection.get_address())
+        except CommandError:
+            return None
+
+    def activate(self, steal_focus=False):
+        asn = subprocess.check_output(
+            ["lsappinfo", "visibleprocesslist", "-includehidden"]
+        ).decode("utf-8")
+        frontmost_asn = asn.split(" ")[0]
+        pid_info_frontmost = subprocess.check_output(
+            ["lsappinfo", "info", "-only", "pid", frontmost_asn]
+        ).decode("utf-8")
+        pid_frontmost = int(pid_info_frontmost.split("=")[1])
+        try:
+            appscript.app("System Events").processes[
+                its.unix_id == self.pid
+            ].frontmost.set(True)
+            if not steal_focus:
+                appscript.app("System Events").processes[
+                    its.unix_id == pid_frontmost
+                ].frontmost.set(True)
+        except CommandError:
+            pass  # may require root privileges (GH 1966)
+
+    @property
+    def visible(self):
+        try:
+            return (
+                appscript.app("System Events")
+                .processes[its.unix_id == self.pid]
+                .visible.get()[0]
+            )
+        except CommandError:
+            return None  # may require root privileges (GH 1966)
+
+    @visible.setter
+    def visible(self, visible):
+        try:
+            appscript.app("System Events").processes[
+                its.unix_id == self.pid
+            ].visible.set(visible)
+        except CommandError:
+            pass  # may require root privileges (GH 1966)
+
+    def quit(self):
+        self.xl.quit(saving=kw.no)
+
+    def kill(self):
+        psutil.Process(self.pid).kill()
+
+    @property
+    def screen_updating(self):
+        return self.xl.screen_updating.get()
+
+    @screen_updating.setter
+    def screen_updating(self, value):
+        self.xl.screen_updating.set(value)
+
+    @property
+    def display_alerts(self):
+        return self.xl.display_alerts.get()
+
+    @display_alerts.setter
+    def display_alerts(self, value):
+        self.xl.display_alerts.set(value)
+
+    @property
+    def enable_events(self):
+        return self.xl.enable_events.get()
+
+    @enable_events.setter
+    def enable_events(self, value):
+        self.xl.enable_events.set(value)
+
+    @property
+    def interactive(self):
+        # TODO: replace with specific error when Exceptions are refactored
+        raise xlwings.XlwingsError(
+            "Getting or setting 'app.interactive' isn't supported on macOS."
+        )
+
+    @interactive.setter
+    def interactive(self, value):
+        # TODO: replace with specific error when Exceptions are refactored
+        raise xlwings.XlwingsError(
+            "Getting or setting 'app.interactive' isn't supported on macOS."
+        )
+
+    @property
+    def startup_path(self):
+        return hfs_to_posix_path(self.xl.startup_path.get())
+
+    @property
+    def calculation(self):
+        return calculation_k2s[self.xl.calculation.get()]
+
+    @calculation.setter
+    def calculation(self, value):
+        self.xl.calculation.set(calculation_s2k[value])
+
+    def calculate(self):
+        self.xl.calculate()
+
+    @property
+    def books(self):
+        return Books(self)
+
+    @property
+    def hwnd(self):
+        return None
+
+    def run(self, macro, args):
+        kwargs = {"arg{0}".format(i): n for i, n in enumerate(args, 1)}
+        return self.xl.run_VB_macro(macro, **kwargs)
+
+    @property
+    def status_bar(self):
+        return self.xl.status_bar.get()
+
+    @status_bar.setter
+    def status_bar(self, value):
+        self.xl.status_bar.set(value)
+
+    @property
+    def cut_copy_mode(self):
+        modes = {kw.cut_mode: "cut", kw.copy_mode: "copy"}
+        return modes.get(self.xl.cut_copy_mode.get())
+
+    @cut_copy_mode.setter
+    def cut_copy_mode(self, value):
+        self.xl.cut_copy_mode.set(value)
+
+    def alert(self, prompt, title, buttons, mode, callback):
+        # OSAX (Open Scripting Architecture Extension) instance for StandardAdditions
+        # See /System/Library/ScriptingAdditions/StandardAdditions.osax
+        sa = osax.OSAX(pid=self.pid)
+        sa.activate()  # Activate app so dialog box will be visible
+        modes = {
+            None: kw.informational,
+            "info": kw.informational,
+            "critical": kw.critical,
+        }
+        buttons_dict = {
+            None: "OK",
+            "ok": "OK",
+            "ok_cancel": ["Cancel", "OK"],
+            "yes_no": ["No", "Yes"],
+            "yes_no_cancel": ["Cancel", "No", "Yes"],
+        }
+        rv = sa.display_alert(
+            "" if title is None else title,
+            message="" if prompt is None else prompt,
+            buttons=buttons_dict[buttons],
+            as_=modes[mode],
+        )
+        return rv[kw.button_returned].lower()
+
+
+class Books(base_classes.Books):
+    def __init__(self, app):
+        self.app = app
+
+    @property
+    def api(self):
+        return None
+
+    @property
+    def active(self):
+        return Book(self.app, self.app.xl.active_workbook.name.get())
+
+    def __call__(self, name_or_index):
+        b = Book(self.app, name_or_index)
+        if not b.xl.exists():
+            raise KeyError(name_or_index)
+        return b
+
+    def __contains__(self, key):
+        return Book(self.app, key).xl.exists()
+
+    def __len__(self):
+        return self.app.xl.count(each=kw.workbook)
+
+    def add(self):
+        if self.app.visible:
+            self.app.activate()
+        xl = self.app.xl.make(new=kw.workbook)
+        wb = Book(self.app, xl.name.get())
+        return wb
+
+    def open(
+        self,
+        fullname,
+        update_links=None,
+        read_only=None,
+        format=None,
+        password=None,
+        write_res_password=None,
+        ignore_read_only_recommended=None,
+        origin=None,
+        delimiter=None,
+        editable=None,
+        notify=None,
+        converter=None,
+        add_to_mru=None,
+        local=None,
+        corrupt_load=None,
+    ):
+        # TODO: format and origin currently require a native appscript keyword,
+        #  read_only doesn't seem to work
+        # Unsupported params
+        if local is not None:
+            # TODO: replace with specific error when Exceptions are refactored
+            raise xlwings.XlwingsError("local is not supported on macOS")
+        if corrupt_load is not None:
+            # TODO: replace with specific error when Exceptions are refactored
+            raise xlwings.XlwingsError("corrupt_load is not supported on macOS")
+        # update_links: on Windows only constants 0 and 3 seem to be supported in
+        # this context
+        if update_links:
+            update_links = kw.update_remote_and_external_links
+        else:
+            update_links = kw.do_not_update_links
+        if self.app.visible:
+            self.app.activate()
+        filename = os.path.basename(fullname)
+        self.app.xl.open_workbook(
+            workbook_file_name=fullname,
+            update_links=update_links,
+            read_only=read_only,
+            format=format,
+            password=password,
+            write_reserved_password=write_res_password,
+            ignore_read_only_recommended=ignore_read_only_recommended,
+            origin=origin,
+            delimiter=delimiter,
+            editable=editable,
+            notify=notify,
+            converter=converter,
+            add_to_mru=add_to_mru,
+            timeout=-1,
+        )
+        wb = Book(self.app, filename)
+        return wb
+
+    def __iter__(self):
+        n = len(self)
+        for i in range(n):
+            yield Book(self.app, i + 1)
+
+
+class Book(base_classes.Book):
+    def __init__(self, app, name_or_index):
+        self._app = app
+        self.xl = app.xl.workbooks[name_or_index]
+
+    @property
+    def app(self):
+        return self._app
+
+    @property
+    def api(self):
+        return self.xl
+
+    def json(self):
+        raise NotImplementedError()
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @property
+    def sheets(self):
+        return Sheets(self)
+
+    def close(self):
+        self.xl.close(saving=kw.no)
+
+    def save(self, path, password):
+        saved_path = self.xl.properties().get(kw.path)
+        source_ext = os.path.splitext(self.name)[1] if saved_path else None
+        target_ext = os.path.splitext(path)[1] if path else ".xlsx"
+        if saved_path and source_ext == target_ext:
+            file_format = self.xl.properties().get(kw.file_format)
+        else:
+            ext_to_file_format = {
+                ".xlsx": kw.Excel_XML_file_format,
+                ".xlsm": kw.macro_enabled_XML_file_format,
+                ".xlsb": kw.Excel_binary_file_format,
+                ".xltm": kw.macro_enabled_template_file_format,
+                ".xltx": kw.template_file_format,
+                ".xlam": kw.add_in_file_format,
+                ".xls": kw.Excel98to2004_file_format,
+                ".xlt": kw.Excel98to2004_template_file_format,
+                ".xla": kw.Excel98to2004_add_in_file_format,
+            }
+
+            file_format = ext_to_file_format[target_ext]
+        if (saved_path != "") and (path is None):
+            # Previously saved: Save under existing name
+            self.xl.save(timeout=-1)
+        elif (
+            (saved_path != "") and (path is not None) and (os.path.split(path)[0] == "")
+        ):
+            # Save existing book under new name in cwd if no path has been provided
+            save_as_name = path
+            path = os.path.join(os.getcwd(), path)
+            hfs_path = posix_to_hfs_path(os.path.realpath(path))
+            self.xl.save_workbook_as(
+                filename=hfs_path,
+                overwrite=True,
+                file_format=file_format,
+                timeout=-1,
+                password=password,
+            )
+            self.xl = self.app.xl.workbooks[save_as_name]
+        elif (saved_path == "") and (path is None):
+            # Previously unsaved: Save under current name in current working directory
+            save_as_name = self.xl.name.get() + ".xlsx"
+            path = os.path.join(os.getcwd(), save_as_name)
+            hfs_path = posix_to_hfs_path(os.path.realpath(path))
+            self.xl.save_workbook_as(
+                filename=hfs_path,
+                overwrite=True,
+                file_format=file_format,
+                timeout=-1,
+                password=password,
+            )
+            self.xl = self.app.xl.workbooks[save_as_name]
+        elif path:
+            # Save under new name/location
+            hfs_path = posix_to_hfs_path(os.path.realpath(path))
+            self.xl.save_workbook_as(
+                filename=hfs_path,
+                overwrite=True,
+                file_format=file_format,
+                timeout=-1,
+                password=password,
+            )
+            self.xl = self.app.xl.workbooks[os.path.basename(path)]
+
+    @property
+    def fullname(self):
+        display_alerts = self.app.display_alerts
+        self.app.display_alerts = False
+        # This causes a pop-up if there's a pw protected sheet, see #1377
+        path = self.xl.properties().get(kw.full_name)
+        if "://" in path:
+            config = read_config_sheet(xlwings.Book(impl=self))
+            self.app.display_alerts = display_alerts
+            return fullname_url_to_local_path(
+                url=path,
+                sheet_onedrive_consumer_config=config.get("ONEDRIVE_CONSUMER_MAC"),
+                sheet_onedrive_commercial_config=config.get("ONEDRIVE_COMMERCIAL_MAC"),
+                sheet_sharepoint_config=config.get("SHAREPOINT_MAC"),
+            )
+        else:
+            self.app.display_alerts = display_alerts
+            return path
+
+    @property
+    def names(self):
+        return Names(parent=self, xl=self.xl.named_items)
+
+    def activate(self):
+        self.xl.activate_object()
+
+    def to_pdf(self, path, quality=None):
+        # quality parameter for compatibility
+        hfs_path = posix_to_hfs_path(path)
+        display_alerts = self.app.display_alerts
+        self.app.display_alerts = False
+        if Path(path).exists():
+            # Errors out with Parameter error (OSERROR: -50) otherwise
+            os.unlink(path)
+        self.xl.save(in_=hfs_path, as_=kw.PDF_file_format)
+        self.app.display_alerts = display_alerts
+
+
+class Sheets(base_classes.Sheets):
+    def __init__(self, workbook):
+        self.workbook = workbook
+
+    @property
+    def api(self):
+        return None
+
+    @property
+    def active(self):
+        return Sheet(self.workbook, self.workbook.xl.active_sheet.name.get())
+
+    def __call__(self, name_or_index):
+        return Sheet(self.workbook, name_or_index)
+
+    def __len__(self):
+        return self.workbook.xl.count(each=kw.worksheet)
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self(i + 1)
+
+    def add(self, before=None, after=None, name=None):
+        if before is None and after is None:
+            before = self.workbook.app.books.active.sheets.active
+        if before:
+            position = before.xl.before
+        else:
+            position = after.xl.after
+        xl = self.workbook.xl.make(new=kw.worksheet, at=position)
+        if name is not None:
+            xl.name.set(name)
+            xl = self.workbook.xl.worksheets[name]
+        return Sheet(self.workbook, xl.name.get())
+
+
+class Sheet(base_classes.Sheet):
+    def __init__(self, workbook, name_or_index):
+        self.workbook = workbook
+        self.xl = workbook.xl.worksheets[name_or_index]
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        self.xl.name.set(value)
+        self.xl = self.workbook.xl.worksheets[value]
+
+    @property
+    def names(self):
+        return Names(parent=self, xl=self.xl.named_items)
+
+    @property
+    def book(self):
+        return self.workbook
+
+    @property
+    def index(self):
+        return self.xl.entry_index.get()
+
+    def range(self, arg1, arg2=None):
+        if isinstance(arg1, tuple):
+            if len(arg1) == 2:
+                if 0 in arg1:
+                    raise IndexError(
+                        "Attempted to access 0-based Range. "
+                        "xlwings/Excel Ranges are 1-based."
+                    )
+                row1 = arg1[0]
+                col1 = arg1[1]
+                address1 = self.xl.rows[row1].columns[col1].get_address()
+            elif len(arg1) == 4:
+                return Range(self, arg1)
+            else:
+                raise ValueError("Invalid parameters")
+        elif isinstance(arg1, Range):
+            row1 = min(arg1.row, arg2.row)
+            col1 = min(arg1.column, arg2.column)
+            address1 = self.xl.rows[row1].columns[col1].get_address()
+        elif isinstance(arg1, str):
+            address1 = arg1.split(":")[0]
+        else:
+            raise ValueError("Invalid parameters")
+
+        if isinstance(arg2, tuple):
+            if 0 in arg2:
+                raise IndexError(
+                    "Attempted to access 0-based Range. "
+                    "xlwings/Excel Ranges are 1-based."
+                )
+            row2 = arg2[0]
+            col2 = arg2[1]
+            address2 = self.xl.rows[row2].columns[col2].get_address()
+        elif isinstance(arg2, Range):
+            row2 = max(arg1.row + arg1.shape[0] - 1, arg2.row + arg2.shape[0] - 1)
+            col2 = max(arg1.column + arg1.shape[1] - 1, arg2.column + arg2.shape[1] - 1)
+            address2 = self.xl.rows[row2].columns[col2].get_address()
+        elif isinstance(arg2, str):
+            address2 = arg2
+        elif arg2 is None:
+            if isinstance(arg1, str) and len(arg1.split(":")) == 2:
+                address2 = arg1.split(":")[1]
+            else:
+                return Range(self, "{0}".format(address1))
+        else:
+            raise ValueError("Invalid parameters")
+
+        return Range(self, "{0}:{1}".format(address1, address2))
+
+    @property
+    def cells(self):
+        return self.range(
+            (1, 1), (self.xl.count(each=kw.row), self.xl.count(each=kw.column))
+        )
+
+    def activate(self):
+        self.xl.activate_object()
+
+    def select(self):
+        self.xl.select()
+
+    def clear_contents(self):
+        self.xl.used_range.clear_contents()
+
+    def clear_formats(self):
+        self.xl.used_range.clear_formats()
+
+    def clear(self):
+        self.xl.used_range.clear_range()
+
+    def autofit(self, axis=None):
+        num_columns = self.xl.count(each=kw.column)
+        num_rows = self.xl.count(each=kw.row)
+        address = self.range((1, 1), (num_rows, num_columns)).address
+        alerts_state = self.book.app.screen_updating
+        self.book.app.screen_updating = False
+        if axis == "rows" or axis == "r":
+            self.xl.rows[address].autofit()
+        elif axis == "columns" or axis == "c":
+            self.xl.columns[address].autofit()
+        elif axis is None:
+            self.xl.rows[address].autofit()
+            self.xl.columns[address].autofit()
+        self.book.app.screen_updating = alerts_state
+
+    def delete(self):
+        alerts_state = self.book.app.xl.display_alerts.get()
+        self.book.app.xl.display_alerts.set(False)
+        self.xl.delete()
+        self.book.app.xl.display_alerts.set(alerts_state)
+
+    def copy(self, before, after):
+        if before:
+            before = before.xl
+        if after:
+            after = after.xl
+        self.xl.copy_worksheet(before_=before, after_=after)
+
+    @property
+    def charts(self):
+        return Charts(self)
+
+    @property
+    def shapes(self):
+        return Shapes(self)
+
+    @property
+    def tables(self):
+        return Tables(self)
+
+    @property
+    def pictures(self):
+        return Pictures(self)
+
+    @property
+    def used_range(self):
+        return Range(self, self.xl.used_range.get_address())
+
+    @property
+    def visible(self):
+        return True if self.xl.visible.get() == kw.sheet_visible else False
+
+    @visible.setter
+    def visible(self, value):
+        self.xl.visible.set(value)
+
+    @property
+    def page_setup(self):
+        return PageSetup(self, self.xl.page_setup_object)
+
+
+class Range(base_classes.Range):
+    def __init__(self, sheet, address):
+        self.sheet = sheet
+        self.options = None  # Assigned by main.Range to keep API of sheet.range clean
+        if isinstance(address, tuple):
+            self._coords = address
+            row, col, nrows, ncols = address
+            if nrows and ncols:
+                self.xl = sheet.xl.cells[
+                    "%s:%s"
+                    % (
+                        sheet.xl.rows[row].columns[col].get_address(),
+                        sheet.xl.rows[row + nrows - 1]
+                        .columns[col + ncols - 1]
+                        .get_address(),
+                    )
+                ]
+            else:
+                self.xl = None
+        else:
+            self.xl = sheet.xl.cells[address]
+            self._coords = None
+
+    @property
+    def coords(self):
+        if self._coords is None:
+            self._coords = (
+                self.xl.first_row_index.get(),
+                self.xl.first_column_index.get(),
+                self.xl.count(each=kw.row),
+                self.xl.count(each=kw.column),
+            )
+        return self._coords
+
+    @property
+    def api(self):
+        return self.xl
+
+    def __len__(self):
+        return self.coords[2] * self.coords[3]
+
+    @property
+    def row(self):
+        return self.coords[0]
+
+    @property
+    def column(self):
+        return self.coords[1]
+
+    @property
+    def shape(self):
+        return self.coords[2], self.coords[3]
+
+    @property
+    def raw_value(self):
+        def ensure_2d(values):
+            # Usually done in converter, but macOS doesn't deliver any info about
+            # errors with values
+            if not isinstance(values, list):
+                return [[values]]
+            elif not isinstance(values[0], list):
+                return [values]
+
+        if self.xl is not None:
+            values = self.xl.value.get()
+            if self.options.get("err_to_str", False):
+                string_values = self.xl.string_value.get()
+                values = ensure_2d(values)
+                string_values = ensure_2d(string_values)
+                for row_ix, row in enumerate(string_values):
+                    for col_ix, c in enumerate(row):
+                        if c in cell_errors:
+                            values[row_ix][col_ix] = c
+            return values
+
+    @raw_value.setter
+    def raw_value(self, value):
+        if self.xl is not None:
+            self.xl.value.set(value)
+
+    def clear_contents(self):
+        if self.xl is not None:
+            alerts_state = self.sheet.book.app.screen_updating
+            self.sheet.book.app.screen_updating = False
+            self.xl.clear_contents()
+            self.sheet.book.app.screen_updating = alerts_state
+
+    def clear_formats(self):
+        if self.xl is not None:
+            alerts_state = self.sheet.book.app.screen_updating
+            self.sheet.book.app.screen_updating = False
+            self.xl.clear_formats()
+            self.sheet.book.app.screen_updating = alerts_state
+
+    def clear(self):
+        if self.xl is not None:
+            alerts_state = self.sheet.book.app.screen_updating
+            self.sheet.book.app.screen_updating = False
+            self.xl.clear_range()
+            self.sheet.book.app.screen_updating = alerts_state
+
+    def end(self, direction):
+        direction = directions_s2k.get(direction, direction)
+        return Range(self.sheet, self.xl.get_end(direction=direction).get_address())
+
+    @property
+    def formula(self):
+        if self.xl is not None:
+            return self.xl.formula.get()
+
+    @formula.setter
+    def formula(self, value):
+        if self.xl is not None:
+            self.xl.formula.set(value)
+
+    @property
+    def formula2(self):
+        if self.xl is not None:
+            return self.xl.formula2.get()
+
+    @formula2.setter
+    def formula2(self, value):
+        if self.xl is not None:
+            self.xl.formula2.set(value)
+
+    @property
+    def formula_array(self):
+        if self.xl is not None:
+            rv = self.xl.formula_array.get()
+            return None if rv == kw.missing_value else rv
+
+    @formula_array.setter
+    def formula_array(self, value):
+        if self.xl is not None:
+            self.xl.formula_array.set(value)
+
+    @property
+    def font(self):
+        return Font(self, self.xl.font_object)
+
+    @property
+    def column_width(self):
+        if self.xl is not None:
+            rv = self.xl.column_width.get()
+            return None if rv == kw.missing_value else rv
+        else:
+            return 0
+
+    @column_width.setter
+    def column_width(self, value):
+        if self.xl is not None:
+            self.xl.column_width.set(value)
+
+    @property
+    def row_height(self):
+        if self.xl is not None:
+            rv = self.xl.row_height.get()
+            return None if rv == kw.missing_value else rv
+        else:
+            return 0
+
+    @row_height.setter
+    def row_height(self, value):
+        if self.xl is not None:
+            self.xl.row_height.set(value)
+
+    @property
+    def width(self):
+        if self.xl is not None:
+            return self.xl.width.get()
+        else:
+            return 0
+
+    @property
+    def height(self):
+        if self.xl is not None:
+            return self.xl.height.get()
+        else:
+            return 0
+
+    @property
+    def left(self):
+        return self.xl.properties().get(kw.left_position)
+
+    @property
+    def top(self):
+        return self.xl.properties().get(kw.top)
+
+    @property
+    def has_array(self):
+        if self.xl is not None:
+            return self.xl.has_array.get()
+
+    @property
+    def number_format(self):
+        if self.xl is not None:
+            rv = self.xl.number_format.get()
+            return None if rv == kw.missing_value else rv
+
+    @number_format.setter
+    def number_format(self, value):
+        if self.xl is not None:
+            alerts_state = self.sheet.book.app.screen_updating
+            self.sheet.book.app.screen_updating = False
+            self.xl.number_format.set(value)
+            self.sheet.book.app.screen_updating = alerts_state
+
+    def get_address(self, row_absolute, col_absolute, external):
+        if self.xl is not None:
+            return self.xl.get_address(
+                row_absolute=row_absolute,
+                column_absolute=col_absolute,
+                external=external,
+            )
+
+    @property
+    def address(self):
+        if self.xl is not None:
+            return self.xl.get_address()
+        else:
+            row, col, nrows, ncols = self.coords
+            return "$%s$%s{%sx%s}" % (col_name(col), row, nrows, ncols)
+
+    @property
+    def current_region(self):
+        return Range(self.sheet, self.xl.current_region.get_address())
+
+    def autofit(self, axis=None):
+        if self.xl is not None:
+            address = self.address
+            alerts_state = self.sheet.book.app.screen_updating
+            self.sheet.book.app.screen_updating = False
+            if axis == "rows" or axis == "r":
+                self.sheet.xl.rows[address].autofit()
+            elif axis == "columns" or axis == "c":
+                self.sheet.xl.columns[address].autofit()
+            elif axis is None:
+                self.sheet.xl.rows[address].autofit()
+                self.sheet.xl.columns[address].autofit()
+            self.sheet.book.app.screen_updating = alerts_state
+
+    def insert(self, shift=None, copy_origin=None):
+        # copy_origin is not supported on mac
+        shifts = {"down": kw.shift_down, "right": kw.shift_to_right, None: None}
+        self.xl.insert_into_range(shift=shifts[shift])
+
+    def delete(self, shift=None):
+        shifts = {"up": kw.shift_up, "left": kw.shift_to_left, None: None}
+        self.xl.delete_range(shift=shifts[shift])
+
+    def copy(self, destination=None):
+        self.xl.copy_range(destination=destination.api if destination else None)
+
+    def paste(self, paste=None, operation=None, skip_blanks=False, transpose=False):
+        pastes = {
+            # all_merging_conditional_formats unsupported on mac
+            "all": kw.paste_all,
+            "all_except_borders": kw.paste_all_except_borders,
+            "all_using_source_theme": kw.paste_all_using_source_theme,
+            "column_widths": kw.paste_column_widths,
+            "comments": kw.paste_comments,
+            "formats": kw.paste_formats,
+            "formulas": kw.paste_formulas,
+            "formulas_and_number_formats": kw.paste_formulas_and_number_formats,
+            "validation": kw.paste_validation,
+            "values": kw.paste_values,
+            "values_and_number_formats": kw.paste_values_and_number_formats,
+            None: None,
+        }
+
+        operations = {
+            "add": kw.paste_special_operation_add,
+            "divide": kw.paste_special_operation_divide,
+            "multiply": kw.paste_special_operation_multiply,
+            "subtract": kw.paste_special_operation_subtract,
+            None: None,
+        }
+
+        self.xl.paste_special(
+            what=pastes[paste],
+            operation=operations[operation],
+            skip_blanks=skip_blanks,
+            transpose=transpose,
+        )
+
+    @property
+    def hyperlink(self):
+        try:
+            return self.xl.hyperlinks[1].address.get()
+        except CommandError:
+            raise Exception("The cell doesn't seem to contain a hyperlink!")
+
+    def add_hyperlink(self, address, text_to_display=None, screen_tip=None):
+        if self.xl is not None:
+            self.xl.make(
+                at=self.xl,
+                new=kw.hyperlink,
+                with_properties={
+                    kw.address: address,
+                    kw.text_to_display: text_to_display,
+                    kw.screen_tip: screen_tip,
+                },
+            )
+
+    @property
+    def color(self):
+        if (
+            not self.xl
+            or self.xl.interior_object.color_index.get() == kw.color_index_none
+        ):
+            return None
+        else:
+            return tuple(self.xl.interior_object.color.get())
+
+    @color.setter
+    def color(self, color_or_rgb):
+        if isinstance(color_or_rgb, str):
+            color_or_rgb = utils.hex_to_rgb(color_or_rgb)
+        if self.xl is not None:
+            if color_or_rgb is None:
+                self.xl.interior_object.color_index.set(ColorIndex.xlColorIndexNone)
+            elif isinstance(color_or_rgb, int):
+                self.xl.interior_object.color.set(int_to_rgb(color_or_rgb))
+            else:
+                self.xl.interior_object.color.set(color_or_rgb)
+
+    @property
+    def name(self):
+        if not self.xl:
+            return None
+        xl = self.xl.named_item
+        if xl.get() == kw.missing_value:
+            return None
+        else:
+            return Name(self.sheet.book, xl=xl)
+
+    @name.setter
+    def name(self, value):
+        if self.xl is not None:
+            self.xl.name.set(value)
+
+    def __call__(self, arg1, arg2=None):
+        if arg2 is None:
+            col = (arg1 - 1) % self.shape[1]
+            row = int((arg1 - 1 - col) / self.shape[1])
+            return self(1 + row, 1 + col)
+        else:
+            return Range(
+                self.sheet,
+                self.sheet.xl.rows[self.row + arg1 - 1]
+                .columns[self.column + arg2 - 1]
+                .get_address(),
+            )
+
+    @property
+    def rows(self):
+        row = self.row
+        col1 = self.column
+        col2 = col1 + self.shape[1] - 1
+        return [
+            self.sheet.range((row + i, col1), (row + i, col2))
+            for i in range(self.shape[0])
+        ]
+
+    @property
+    def columns(self):
+        col = self.column
+        row1 = self.row
+        row2 = row1 + self.shape[0] - 1
+        sht = self.sheet
+        return [
+            sht.range((row1, col + i), (row2, col + i)) for i in range(self.shape[1])
+        ]
+
+    def select(self):
+        if self.xl is not None:
+            return self.xl.select()
+
+    @property
+    def merge_area(self):
+        return Range(self.sheet, self.xl.merge_area.get_address())
+
+    @property
+    def merge_cells(self):
+        return self.xl.merge_cells.get()
+
+    def merge(self, across):
+        self.xl.merge(across=across)
+
+    def unmerge(self):
+        self.xl.unmerge()
+
+    @property
+    def table(self):
+        if self.xl.list_object.name.get() == kw.missing_value:
+            return None
+        else:
+            return Table(self.sheet, self.xl.list_object.name.get())
+
+    @property
+    def characters(self):
+        # This is broken with AppleScript/Excel 2016
+        return Characters(parent=self, xl=self.xl.characters)
+
+    @property
+    def wrap_text(self):
+        return self.xl.wrap_text.get()
+
+    @wrap_text.setter
+    def wrap_text(self, value):
+        self.xl.wrap_text.set(value)
+
+    @property
+    def note(self):
+        try:
+            # No easy way to check whether there's a comment like on Windows
+            return (
+                Note(parent=self, xl=self.xl.Excel_comment)
+                if self.xl.Excel_comment.Excel_comment_text()
+                else None
+            )
+        except appscript.reference.CommandError:
+            return None
+
+    def copy_picture(self, appearance, format):
+        _appearance = {"screen": kw.screen, "printer": kw.printer}
+        _format = {"picture": kw.picture, "bitmap": kw.bitmap}
+        self.xl.copy_picture(appearance=_appearance[appearance], format=_format[format])
+
+    def to_png(self, path):
+        self.copy_picture(appearance="screen", format="bitmap")
+        im = ImageGrab.grabclipboard()
+        im.save(path)
+
+    def to_pdf(self, path, quality=None):
+        raise xlwings.XlwingsError("Range.to_pdf() isn't supported on macOS.")
+
+    def autofill(self, destination, type_):
+        types = {
+            "fill_copy": kw.fill_copy,
+            "fill_days": kw.fill_days,
+            "fill_default": kw.fill_default,
+            "fill_formats": kw.fill_formats,
+            "fill_months": kw.fill_months,
+            "fill_series": kw.fill_series,
+            "fill_values": kw.fill_values,
+            "fill_weekdays": kw.fill_weekdays,
+            "fill_years": kw.fill_years,
+            "growth_trend": kw.growth_trend,
+            "linear_trend": kw.linear_trend,
+            "flash_fill": kw.flashfill,
+        }
+        self.xl.autofill(destination=destination.api, type=types[type_])
+
+
+class Shape(base_classes.Shape):
+    def __init__(self, parent, key):
+        self._parent = parent
+        self.xl = parent.xl.shapes[key]
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        self.xl.name.set(value)
+
+    @property
+    def type(self):
+        return shape_types_k2s[self.xl.shape_type.get()]
+
+    @property
+    def left(self):
+        return self.xl.left_position.get()
+
+    @left.setter
+    def left(self, value):
+        self.xl.left_position.set(value)
+
+    @property
+    def top(self):
+        return self.xl.top.get()
+
+    @top.setter
+    def top(self, value):
+        self.xl.top.set(value)
+
+    @property
+    def width(self):
+        return self.xl.width.get()
+
+    @width.setter
+    def width(self, value):
+        self.xl.width.set(value)
+
+    @property
+    def height(self):
+        return self.xl.height.get()
+
+    @height.setter
+    def height(self, value):
+        self.xl.height.set(value)
+
+    def delete(self):
+        self.xl.delete()
+
+    @property
+    def index(self):
+        return self.xl.entry_index.get()
+
+    def activate(self):
+        # self.xl.activate_object()  # doesn't work?
+        self.xl.select()
+
+    def scale_height(self, factor, relative_to_original_size, scale):
+        self.xl.scale_height(
+            scale=scaling[scale],
+            relative_to_original_size=relative_to_original_size,
+            factor=factor,
+        )
+
+    def scale_width(self, factor, relative_to_original_size, scale):
+        self.xl.scale_width(
+            scale=scaling[scale],
+            relative_to_original_size=relative_to_original_size,
+            factor=factor,
+        )
+
+    @property
+    def text(self):
+        if self.xl.shape_text_frame.has_text.get():
+            return self.xl.shape_text_frame.text_range.content.get()
+
+    @text.setter
+    def text(self, value):
+        self.xl.shape_text_frame.text_range.content.set(value)
+
+    @property
+    def font(self):
+        return Font(self, self.xl.shape_text_frame.text_range.font)
+
+    @property
+    def characters(self):
+        raise AttributeError("Characters isn't supported on macOS with shapes.")
+
+
+class Font(base_classes.Font):
+    def __init__(self, parent, xl):
+        # xl can be font or font_object
+        self.parent = parent
+        self.xl = xl
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def bold(self):
+        return self.xl.bold.get()
+
+    @bold.setter
+    def bold(self, value):
+        self.xl.bold.set(value)
+
+    @property
+    def italic(self):
+        return self.xl.italic.get()
+
+    @italic.setter
+    def italic(self, value):
+        self.xl.italic.set(value)
+
+    @property
+    def size(self):
+        return self.xl.font_size.get()
+
+    @size.setter
+    def size(self, value):
+        self.xl.font_size.set(value)
+
+    @property
+    def color(self):
+        if isinstance(self.parent, Range):
+            return tuple(self.xl.color.get())
+        elif isinstance(self.parent, Shape):
+            return tuple(self.xl.font_color.get())
+
+    @color.setter
+    def color(self, color_or_rgb):
+        if self.xl is not None:
+            if isinstance(self.parent, (Range, Characters)):
+                obj = self.xl.color
+            elif isinstance(self.parent, Shape):
+                obj = self.xl.font_color
+
+            if isinstance(color_or_rgb, int):
+                obj.set(int_to_rgb(color_or_rgb))
+            else:
+                obj.set(color_or_rgb)
+
+    @property
+    def name(self):
+        if isinstance(self.parent, Range):
+            return self.xl.name.get()
+        elif isinstance(self.parent, Shape):
+            return self.xl.font_name.get()
+
+    @name.setter
+    def name(self, value):
+        if isinstance(self.parent, Range):
+            self.xl.name.set(value)
+        elif isinstance(self.parent, Shape):
+            self.xl.font_name.set(value)
+
+
+class Characters(base_classes.Characters):
+    def __init__(self, parent, xl):
+        self.parent = parent
+        self.xl = xl
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def text(self):
+        return self.xl.content.get()
+
+    @property
+    def font(self):
+        return Font(self, self.xl.font_object)
+
+    def __getitem__(self, item):
+        # TODO: This is broken with AppleScript and Excel 2016:
+        # set bold of font object of (characters 5 thru 9 of range "A1") to true
+        # https://answers.microsoft.com/en-us/msoffice/forum/
+        #  msoffice_excel-mso_mac-msoversion_other/applescript-and-excel-problem/
+        #  6e5a50b1-6209-4fbf-91f4-6d6674f1e488
+        if isinstance(item, slice):
+            return Characters(
+                parent=self.parent,
+                xl=self.xl[
+                    item.start + 1
+                    if item.start
+                    else None : item.stop
+                    if item.stop
+                    else len(self.text)
+                ],
+            )
+        else:
+            return Characters(parent=self.parent, xl=self.xl[item + 1 : item + 1])
+
+
+class PageSetup(base_classes.PageSetup):
+    def __init__(self, parent, xl):
+        self.parent = parent
+        self.xl = xl
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def print_area(self):
+        value = self.xl.print_area.get()
+        if value == kw.missing_value:
+            return None
+        else:
+            return self.xl.print_area.get()
+
+    @print_area.setter
+    def print_area(self, value):
+        self.xl.print_area.set("" if value is None else value)
+
+
+class Note(base_classes.Note):
+    def __init__(self, parent, xl):
+        self.parent = parent
+        self.xl = xl
+
+    def api(self):
+        return self.xl
+
+    @property
+    def text(self):
+        return self.xl.Excel_comment_text()
+
+    @text.setter
+    def text(self, value):
+        self.xl.Excel_comment_text(text=value)
+
+    def delete(self):
+        self.parent.xl.clear_Excel_comments()
+
+
+class Collection(base_classes.Collection):
+    def __init__(self, parent):
+        self._parent = parent
+        self.xl = getattr(self.parent.xl, self._attr)
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def api(self):
+        return self.xl
+
+    def __call__(self, key):
+        if not self.xl[key].exists():
+            raise KeyError(key)
+        return self._wrap(self.parent, key)
+
+    def __len__(self):
+        return self.parent.xl.count(each=self._kw)
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self(i + 1)
+
+    def __contains__(self, key):
+        return self.xl[key].exists()
+
+
+class Table(base_classes.Table):
+    def __init__(self, parent, key):
+        self._parent = parent
+        self.xl = parent.xl.list_objects[key]
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        self.xl.name.set(value)
+        self.xl = self.parent.xl.list_objects[value]
+
+    @property
+    def data_body_range(self):
+        if self.xl.cell_table.get() == kw.missing_value:
+            return
+        else:
+            return Range(self.parent, self.xl.cell_table.get_address())
+
+    @property
+    def display_name(self):
+        return self.xl.display_name.get()
+
+    @display_name.setter
+    def display_name(self, value):
+        # Changing the display_name also changes the name
+        self.xl.display_name.set(value)
+        self.xl = self.parent.xl.list_objects[value]
+
+    @property
+    def header_row_range(self):
+        if self.xl.header_row.get() == kw.missing_value:
+            return
+        else:
+            return Range(self.parent, self.xl.header_row.get_address())
+
+    @property
+    def insert_row_range(self):
+        if self.xl.insert_row.get() == kw.missing_value:
+            return
+        else:
+            return Range(self.parent, self.xl.insert_row.get_address())
+
+    @property
+    def range(self):
+        return Range(self.parent, self.xl.range_object.get_address())
+
+    @property
+    def show_autofilter(self):
+        return self.xl.show_autofilter.get()
+
+    @show_autofilter.setter
+    def show_autofilter(self, value):
+        self.xl.show_autofilter.set(value)
+
+    @property
+    def show_headers(self):
+        return self.xl.show_headers.get()
+
+    @show_headers.setter
+    def show_headers(self, value):
+        self.xl.show_headers.set(value)
+
+    @property
+    def show_table_style_column_stripes(self):
+        return self.xl.show_table_style_column_stripes.get()
+
+    @show_table_style_column_stripes.setter
+    def show_table_style_column_stripes(self, value):
+        self.xl.show_table_style_column_stripes.set(value)
+
+    @property
+    def show_table_style_first_column(self):
+        return self.xl.show_table_style_first_column.get()
+
+    @show_table_style_first_column.setter
+    def show_table_style_first_column(self, value):
+        self.xl.show_table_style_first_column.set(value)
+
+    @property
+    def show_table_style_last_column(self):
+        return self.xl.show_table_style_last_column.get()
+
+    @show_table_style_last_column.setter
+    def show_table_style_last_column(self, value):
+        self.xl.show_table_style_last_column.set(value)
+
+    @property
+    def show_table_style_row_stripes(self):
+        return self.xl.show_table_style_row_stripes.get()
+
+    @show_table_style_row_stripes.setter
+    def show_table_style_row_stripes(self, value):
+        self.xl.show_table_style_row_stripes.set(value)
+
+    @property
+    def show_totals(self):
+        return self.xl.total.get()
+
+    @show_totals.setter
+    def show_totals(self, value):
+        self.xl.total.set(value)
+
+    @property
+    def table_style(self):
+        return self.xl.table_style.properties().get(kw.name)
+
+    @table_style.setter
+    def table_style(self, value):
+        self.xl.table_style.set(value)
+
+    @property
+    def totals_row_range(self):
+        if self.xl.total_row.get() == kw.missing_value:
+            return
+        else:
+            return Range(self.parent, self.xl.total_row.get_address())
+
+    def resize(self, range):
+        self.xl.resize(range=range.api)
+
+
+class Tables(Collection, base_classes.Tables):
+    _attr = "list_objects"
+    _kw = kw.list_object
+    _wrap = Table
+
+    def add(
+        self,
+        source_type=None,
+        source=None,
+        link_source=None,
+        has_headers=None,
+        destination=None,
+        table_style_name=None,
+        name=None,
+    ):
+        header_row = {
+            True: kw.header_yes,
+            False: kw.header_no,
+            "guess": kw.header_guess,
+        }
+        sheet_index = self.parent.xl.entry_index.get()
+        table = Table(
+            self.parent,
+            self.parent.xl.make(
+                at=self.parent.book.xl.sheets[sheet_index],
+                new=kw.list_object,
+                with_properties={
+                    kw.source_type: kw.src_range,
+                    kw.range_object: source.api,
+                    kw.header_row: header_row[has_headers],
+                    kw.table_style: table_style_name,
+                },
+            ).name.get(),
+        )
+        if name is not None:
+            table.name = name
+        return table
+
+
+class Chart(base_classes.Chart):
+    def __init__(self, parent, key):
+        self._parent = parent
+        if isinstance(parent, Sheet):
+            self.xl_obj = parent.xl.chart_objects[key]
+            self.xl = self.xl_obj.chart
+        else:
+            self.xl_obj = None
+            self.xl = self.charts[key]
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def api(self):
+        return self.xl_obj, self.xl
+
+    def set_source_data(self, rng):
+        self.xl.set_source_data(source=rng.xl)
+
+    @property
+    def name(self):
+        if self.xl_obj is not None:
+            return self.xl_obj.name.get()
+        else:
+            return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        if self.xl_obj is not None:
+            self.xl_obj.name.set(value)
+        else:
+            self.xl.name.get(value)
+
+    @property
+    def chart_type(self):
+        return chart_types_k2s[self.xl.chart_type.get()]
+
+    @chart_type.setter
+    def chart_type(self, value):
+        self.xl.chart_type.set(chart_types_s2k[value])
+
+    @property
+    def left(self):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        return self.xl_obj.left_position.get()
+
+    @left.setter
+    def left(self, value):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        self.xl_obj.left_position.set(value)
+
+    @property
+    def top(self):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        return self.xl_obj.top.get()
+
+    @top.setter
+    def top(self, value):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        self.xl_obj.top.set(value)
+
+    @property
+    def width(self):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        return self.xl_obj.width.get()
+
+    @width.setter
+    def width(self, value):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        self.xl_obj.width.set(value)
+
+    @property
+    def height(self):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        return self.xl_obj.height.get()
+
+    @height.setter
+    def height(self, value):
+        if self.xl_obj is None:
+            raise Exception("This chart is not embedded.")
+        self.xl_obj.height.set(value)
+
+    def delete(self):
+        self.xl_obj.delete()
+
+    def to_png(self, path):
+        raise xlwings.XlwingsError("Chart.to_png() isn't supported on macOS.")
+        # Both versions should work, but seem to be broken with Excel 2016
+        #
+        # Version 1
+        # import uuid
+        # temp_path = posix_to_hfs_path(os.path.expanduser("~")
+        #                               + f"/Library/Containers/com.microsoft.Excel/"
+        #                                 f"Data/{uuid.uuid4()}.png")
+        # self.xl.save_as(filename=temp_path)
+        # shutil.copy2(temp_path, path)
+        # try:
+        #     os.unlink(temp_path)
+        # except:
+        #     pass
+        #
+        # Version 2
+        # self.xl_obj.save_as_picture(file_name=posix_to_hfs_path('...'),
+        #                             picture_type=kw.save_as_PNG_file)
+
+    def to_pdf(self, path, quality=None):
+        raise xlwings.XlwingsError("Chart.to_pdf() isn't supported on macOS.")
+
+
+class Charts(Collection, base_classes.Charts):
+    _attr = "chart_objects"
+    _kw = kw.chart_object
+    _wrap = Chart
+
+    def add(self, left, top, width, height):
+        sheet_index = self.parent.xl.entry_index.get()
+        return Chart(
+            self.parent,
+            self.parent.xl.make(
+                at=self.parent.book.xl.sheets[sheet_index],
+                new=kw.chart_object,
+                with_properties={
+                    kw.width: width,
+                    kw.top: top,
+                    kw.left_position: left,
+                    kw.height: height,
+                },
+            ).name.get(),
+        )
+
+
+class Picture(base_classes.Picture):
+    def __init__(self, parent, key):
+        self._parent = parent
+        self.xl = parent.xl.pictures[key]
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def api(self):
+        return self.xl
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        self.xl.name.set(value)
+
+    @property
+    def left(self):
+        return self.xl.left_position.get()
+
+    @left.setter
+    def left(self, value):
+        self.xl.left_position.set(value)
+
+    @property
+    def top(self):
+        return self.xl.top.get()
+
+    @top.setter
+    def top(self, value):
+        self.xl.top.set(value)
+
+    @property
+    def width(self):
+        return self.xl.width.get()
+
+    @width.setter
+    def width(self, value):
+        self.xl.width.set(value)
+
+    @property
+    def height(self):
+        return self.xl.height.get()
+
+    @height.setter
+    def height(self, value):
+        self.xl.height.set(value)
+
+    def delete(self):
+        self.xl.delete()
+
+    @property
+    def lock_aspect_ratio(self):
+        return self.xl.lock_aspect_ratio.get()
+
+    @lock_aspect_ratio.setter
+    def lock_aspect_ratio(self, value):
+        self.xl.lock_aspect_ratio.set(value)
+
+    def update(self, filename):
+        return utils.excel_update_picture(self, filename)
+
+
+class Pictures(Collection, base_classes.Pictures):
+    _attr = "pictures"
+    _kw = kw.picture
+    _wrap = Picture
+
+    def add(
+        self,
+        filename,
+        link_to_file,
+        save_with_document,
+        left,
+        top,
+        width,
+        height,
+        anchor,
+    ):
+        if anchor:
+            top, left = anchor.top, anchor.left
+
+        version = VersionNumber(self.parent.book.app.version)
+
+        if not link_to_file and version >= 15:
+            # Office 2016 for Mac is sandboxed. This path seems to work without the
+            # need of granting access explicitly.
+            xlwings_picture = (
+                os.path.expanduser("~")
+                + "/Library/Containers/com.microsoft.Excel/Data/xlwings_picture.png"
+            )
+            shutil.copy2(filename, xlwings_picture)
+            filename = xlwings_picture
+
+        sheet_index = self.parent.xl.entry_index.get()
+        picture = Picture(
+            self.parent,
+            self.parent.xl.make(
+                at=self.parent.book.xl.sheets[sheet_index],
+                new=kw.picture,
+                with_properties={
+                    kw.file_name: posix_to_hfs_path(filename),
+                    kw.link_to_file: link_to_file,
+                    kw.save_with_document: save_with_document,
+                    kw.width: width,
+                    kw.height: height,
+                    # Top and left: see below
+                    kw.top: 0,
+                    kw.left_position: 0,
+                },
+            ).name.get(),
+        )
+
+        # Top and left cause an issue in the make command above
+        # if they are not set to 0 when width & height are -1
+        picture.top = top if top else 0
+        picture.left = left if left else 0
+
+        if not link_to_file and version >= 15:
+            os.remove(filename)
+
+        return picture
+
+
+class Names(base_classes.Names):
+    def __init__(self, parent, xl):
+        self.parent = parent
+        self.xl = xl
+
+    def __call__(self, name_or_index):
+        return Name(self.parent, xl=self.xl[name_or_index])
+
+    def contains(self, name_or_index):
+        try:
+            self.xl[name_or_index].get()
+        except appscript.reference.CommandError:
+            # TODO: make more specific
+            return False
+        return True
+
+    def __len__(self):
+        named_items = self.xl.get()
+        if named_items == kw.missing_value:
+            return 0
+        else:
+            return len(named_items)
+
+    def add(self, name, refers_to):
+        return Name(
+            self.parent,
+            self.parent.xl.make(
+                at=self.parent.xl,
+                new=kw.named_item,
+                with_properties={kw.references: refers_to, kw.name: name},
+            ),
+        )
+
+
+class Name(base_classes.Name):
+    def __init__(self, parent, xl):
+        self.parent = parent
+        self.xl = xl
+
+    def delete(self):
+        self.xl.delete()
+
+    @property
+    def name(self):
+        return self.xl.name.get()
+
+    @name.setter
+    def name(self, value):
+        self.xl.name.set(value)
+
+    @property
+    def refers_to(self):
+        return self.xl.properties().get(kw.references)
+
+    @refers_to.setter
+    def refers_to(self, value):
+        self.xl.properties(kw.references).set(value)
+
+    @property
+    def refers_to_range(self):
+        book = self.parent if isinstance(self.parent, Book) else self.parent.book
+        external_address = self.xl.reference_range.get_address(external=True)
+        match = re.search(r"\](.*?)'?!(.*)", external_address)
+        return Range(Sheet(book, match.group(1)), match.group(2))
+
+
+class Shapes(Collection):
+    _attr = "shapes"
+    _kw = kw.shape
+    _wrap = Shape
+
+
+@atexit.register
+def cleanup():
+    """
+    Since AppleScript cannot access Excel while a Macro is running, we have to run the
+    Python call in a background process which makes the call return immediately: we
+    rely on the StatusBar to give the user feedback.
+    This function is triggered when the interpreter exits and runs the CleanUp Macro in
+    VBA to show any errors and to reset the StatusBar.
+    """
+    if is_excel_running():
+        # Prevents Excel from reopening
+        # if it has been closed manually or never been opened
+        for app in Apps():
+            try:
+                app.xl.run_VB_macro("CleanUp")
+            except (CommandError, AttributeError, aem.aemsend.EventError):
+                # Excel files initiated from Python don't have the xlwings VBA module
+                pass
+
+
+def posix_to_hfs_path(posix_path):
+    """
+    Turns a posix path (/Path/file.ext) into an HFS path (Macintosh HD:Path:file.ext)
+    """
+    dir_name, file_name = os.path.split(posix_path)
+    dir_name_hfs = mactypes.Alias(dir_name).hfspath
+    return dir_name_hfs + ":" + file_name
+
+
+def hfs_to_posix_path(hfs_path):
+    """
+    Turns an HFS path (Macintosh HD:Path:file.ext) into a posix path (/Path/file.ext)
+    """
+    url = mactypes.convertpathtourl(hfs_path, 1)  # kCFURLHFSPathStyle = 1
+    return mactypes.converturltopath(url, 0)  # kCFURLPOSIXPathStyle = 0
+
+
+def is_excel_running():
+    for proc in psutil.process_iter():
+        try:
+            if proc.name() == "Microsoft Excel":
+                return True
+        except psutil.NoSuchProcess:
+            pass
+    return False
+
+
+# --- constants ---
+
+chart_types_k2s = {
+    kw.ThreeD_area: "3d_area",
+    kw.ThreeD_area_stacked: "3d_area_stacked",
+    kw.ThreeD_area_stacked_100: "3d_area_stacked_100",
+    kw.ThreeD_bar_clustered: "3d_bar_clustered",
+    kw.ThreeD_bar_stacked: "3d_bar_stacked",
+    kw.ThreeD_bar_stacked_100: "3d_bar_stacked_100",
+    kw.ThreeD_column: "3d_column",
+    kw.ThreeD_column_clustered: "3d_column_clustered",
+    kw.ThreeD_column_stacked: "3d_column_stacked",
+    kw.ThreeD_column_stacked_100: "3d_column_stacked_100",
+    kw.ThreeD_line: "3d_line",
+    kw.ThreeD_pie: "3d_pie",
+    kw.ThreeD_pie_exploded: "3d_pie_exploded",
+    kw.area_chart: "area",
+    kw.area_stacked: "area_stacked",
+    kw.area_stacked_100: "area_stacked_100",
+    kw.bar_clustered: "bar_clustered",
+    kw.bar_of_pie: "bar_of_pie",
+    kw.bar_stacked: "bar_stacked",
+    kw.bar_stacked_100: "bar_stacked_100",
+    kw.bubble: "bubble",
+    kw.bubble_ThreeD_effect: "bubble_3d_effect",
+    kw.column_clustered: "column_clustered",
+    kw.column_stacked: "column_stacked",
+    kw.column_stacked_100: "column_stacked_100",
+    kw.combination_chart: "combination",
+    kw.cone_bar_clustered: "cone_bar_clustered",
+    kw.cone_bar_stacked: "cone_bar_stacked",
+    kw.cone_bar_stacked_100: "cone_bar_stacked_100",
+    kw.cone_col: "cone_col",
+    kw.cone_column_clustered: "cone_col_clustered",
+    kw.cone_column_stacked: "cone_col_stacked",
+    kw.cone_column_stacked_100: "cone_col_stacked_100",
+    kw.cylinder_bar_clustered: "cylinder_bar_clustered",
+    kw.cylinder_bar_stacked: "cylinder_bar_stacked",
+    kw.cylinder_bar_stacked_100: "cylinder_bar_stacked_100",
+    kw.cylinder_column: "cylinder_col",
+    kw.cylinder_column_clustered: "cylinder_col_clustered",
+    kw.cylinder_column_stacked: "cylinder_col_stacked",
+    kw.cylinder_column_stacked_100: "cylinder_col_stacked_100",
+    kw.doughnut: "doughnut",
+    kw.doughnut_exploded: "doughnut_exploded",
+    kw.line_chart: "line",
+    kw.line_markers: "line_markers",
+    kw.line_markers_stacked: "line_markers_stacked",
+    kw.line_markers_stacked_100: "line_markers_stacked_100",
+    kw.line_stacked: "line_stacked",
+    kw.line_stacked_100: "line_stacked_100",
+    kw.pie_chart: "pie",
+    kw.pie_exploded: "pie_exploded",
+    kw.pie_of_pie: "pie_of_pie",
+    kw.pyramid_bar_clustered: "pyramid_bar_clustered",
+    kw.pyramid_bar_stacked: "pyramid_bar_stacked",
+    kw.pyramid_bar_stacked_100: "pyramid_bar_stacked_100",
+    kw.pyramid_column: "pyramid_col",
+    kw.pyramid_column_clustered: "pyramid_col_clustered",
+    kw.pyramid_column_stacked: "pyramid_col_stacked",
+    kw.pyramid_column_stacked_100: "pyramid_col_stacked_100",
+    kw.radar: "radar",
+    kw.radar_filled: "radar_filled",
+    kw.radar_markers: "radar_markers",
+    kw.stock_HLC: "stock_hlc",
+    kw.stock_OHLC: "stock_ohlc",
+    kw.stock_VHLC: "stock_vhlc",
+    kw.stock_VOHLC: "stock_vohlc",
+    kw.surface: "surface",
+    kw.surface_top_view: "surface_top_view",
+    kw.surface_top_view_wireframe: "surface_top_view_wireframe",
+    kw.surface_wireframe: "surface_wireframe",
+    kw.xy_scatter_lines: "xy_scatter_lines",
+    kw.xy_scatter_lines_no_markers: "xy_scatter_lines_no_markers",
+    kw.xy_scatter_smooth: "xy_scatter_smooth",
+    kw.xy_scatter_smooth_no_markers: "xy_scatter_smooth_no_markers",
+    kw.xyscatter: "xy_scatter",
+}
+
+chart_types_s2k = {v: k for k, v in chart_types_k2s.items()}
+
+directions_s2k = {
+    "d": kw.toward_the_bottom,
+    "down": kw.toward_the_bottom,
+    "l": kw.toward_the_left,
+    "left": kw.toward_the_left,
+    "r": kw.toward_the_right,
+    "right": kw.toward_the_right,
+    "u": kw.toward_the_top,
+    "up": kw.toward_the_top,
+}
+
+directions_k2s = {
+    kw.toward_the_bottom: "down",
+    kw.toward_the_left: "left",
+    kw.toward_the_right: "right",
+    kw.toward_the_top: "up",
+}
+
+calculation_k2s = {
+    kw.calculation_automatic: "automatic",
+    kw.calculation_manual: "manual",
+    kw.calculation_semiautomatic: "semiautomatic",
+}
+
+calculation_s2k = {v: k for k, v in calculation_k2s.items()}
+
+shape_types_k2s = {
+    kw.shape_type_3d_model: "3d_model",
+    kw.shape_type_auto: "auto_shape",
+    kw.shape_type_callout: "callout",
+    kw.shape_type_canvas: "canvas",
+    kw.shape_type_chart: "chart",
+    kw.shape_type_comment: "comment",
+    kw.shape_type_content_application: "content_app",
+    kw.shape_type_diagram: "diagram",
+    kw.shape_type_free_form: "free_form",
+    kw.shape_type_graphic: "graphic",
+    kw.shape_type_group: "group",
+    kw.shape_type_embedded_OLE_control: "embedded_ole_object",
+    kw.shape_type_form_control: "form_control",
+    kw.shape_type_line: "line",
+    kw.shape_type_linked_3d_model: "linked_3d_model",
+    kw.shape_type_linked_graphic: "linked_graphic",
+    kw.shape_type_linked_OLE_object: "linked_ole_object",
+    kw.shape_type_linked_picture: "linked_picture",
+    kw.shape_type_OLE_control: "ole_control_object",
+    kw.shape_type_picture: "picture",
+    kw.shape_type_place_holder: "placeholder",
+    kw.shape_type_web_video: "web_video",
+    kw.shape_type_media: "media",
+    kw.shape_type_text_box: "text_box",
+    kw.shape_type_table: "table",
+    kw.shape_type_ink: "ink",
+    kw.shape_type_ink_comment: "ink_comment",
+    kw.shape_type_unset: "unset",
+    kw.shape_type_slicer: "slicer",
+}
+
+scaling = {
+    "scale_from_top_left": kw.scale_from_top_left,
+    "scale_from_bottom_right": kw.scale_from_bottom_right,
+    "scale_from_middle": kw.scale_from_middle,
+}
+
+shape_types_s2k = {v: k for k, v in shape_types_k2s.items()}