xlwings-utils 25.0.8__py3-none-any.whl → 25.1.0__py3-none-any.whl

xlwings_utils/xlwings_utils.py

@@ -5,53 +5,32 @@
 #  /_/\_\|_|  \_/\_/  |_||_| |_| \__, ||___/ _____  \__,_| \__||_||_||___/
 #                                |___/      |_____|
 
-__version__ = "25.0.8"
+__version__ = "25.1.0"
 
 
-import dropbox
 from pathlib import Path
 import os
 import sys
 import math
 import base64
+import requests
+import json
 
-dbx = None
 Pythonista = sys.platform == "ios"
+
 try:
     import xlwings
 
     xlwings = True
+    import pyodide_http
 
 except ImportError:
     xlwings = False
 
 missing = object()
 
-
-def pythonista_environ():
-    """
-    tries to update environment variables from the file environ.toml at top level.
-    should only be used under Pythonista
-    """
-    try:
-        import tomlib
-    except ModuleNotFoundError:
-        import tomli as tomlib
-    from pathlib import Path
-    import os
-
-    environ_file = Path("~/Documents").expanduser() / "environ.toml"
-    with open(environ_file, "rb") as f:
-        d0 = tomlib.load(f)
-        d1 = {}
-        for k0, v0 in d0.items():
-            if isinstance(v0, dict):
-                for k1, v1 in v0.items():
-                    d1[f"{k0}.{k1}".upper()] = v1
-            else:
-                d1[k0.upper()] = v0
-
-        os.environ.update(d1)
+_token = None
+missing = object()
 
 
 def dropbox_init(refresh_token=missing, app_key=missing, app_secret=missing, **kwargs):
@@ -85,10 +64,10 @@ def dropbox_init(refresh_token=missing, app_key=missing, app_secret=missing, **k
     -------
     dropbox object
     """
-    global dbx
 
-    if Pythonista:
-        pythonista_environ()
+    global _token
+    if xlwings:
+        pyodide_http.patch_all()  # to enable chunked mode
 
     if refresh_token is missing:
         if "DROPBOX.REFRESH_TOKEN" in os.environ:
@@ -106,18 +85,22 @@ def dropbox_init(refresh_token=missing, app_key=missing, app_secret=missing, **k
         else:
             raise ValueError("no DROPBOX.APP_SECRET found in environment.")
 
-    _dbx = dropbox.Dropbox(oauth2_refresh_token=refresh_token, app_key=app_key, app_secret=app_secret, **kwargs)
+    resp = requests.post(
+        "https://api.dropbox.com/oauth2/token",
+        data={"grant_type": "refresh_token", "refresh_token": refresh_token, "client_id": app_key, "client_secret": app_secret},
+        timeout=30,
+    )
     try:
-        _dbx.files_list_folder(path="")  # just to test proper credentials
-    except dropbox.exceptions.AuthError:
+        resp.raise_for_status()
+    except requests.exceptions.HTTPError:
         raise ValueError("invalid dropbox credentials")
-    return _dbx
+    _token = resp.json()["access_token"]
 
 
-def _login_dbx():
-    global dbx
-    if dbx is None:
-        dbx = dropbox_init()  # use environment
+def _login_dropbox():
+    global _token
+    if _token is None:
+        dropbox_init()  # use environment
 
 
 def list_dropbox(path="", recursive=False, show_files=True, show_folders=False):
@@ -151,28 +134,31 @@ def list_dropbox(path="", recursive=False, show_files=True, show_folders=False):
     If REFRESH_TOKEN, APP_KEY and APP_SECRET environment variables are specified,
     it is not necessary to call dropbox_init() prior to any dropbox function.
     """
-    _login_dbx()
-    out = []
-    result = dbx.files_list_folder(path, recursive=recursive)
-
-    for entry in result.entries:
-        if show_files and isinstance(entry, dropbox.files.FileMetadata):
-            out.append(entry.path_display)
-        if show_folders and isinstance(entry, dropbox.files.FolderMetadata):
-            out.append(entry.path_display + "/")
-
-    while result.has_more:
-        result = dbx.files_list_folder_continue(result.cursor)
-        for entry in result.entries:
-            if show_files and isinstance(entry, dropbox.files.FileMetadata):
-                out.append(entry.path_display)
-            if show_folders and isinstance(entry, dropbox.files.FolderMetadata):
-                out.append(entry.path_display + "/")
+    _login_dropbox()
+
+    API_RPC = "https://api.dropboxapi.com/2"
+    headers = {"Authorization": f"Bearer {_token}", "Content-Type": "application/json"}
+    payload = {"path": path, "recursive": recursive, "include_deleted": False}
+    r = requests.post("https://api.dropboxapi.com/2/files/list_folder", headers=headers, json=payload, timeout=30)
+    r.raise_for_status()
+    data = r.json()
+    entries = data["entries"]
+    while data.get("has_more"):
+        r = requests.post(f"{API_RPC}/files/list_folder/continue", headers=headers, json={"cursor": data["cursor"]}, timeout=30)
+        r.raise_for_status()
+        data = r.json()
+        entries.extend(data["entries"])
 
-    return out
+    result = []
+    for entry in entries:
+        if show_files and entry[".tag"] == "file":
+            result.append(entry["path_display"])
+        if show_folders and entry[".tag"] == "folder":
+            result.append(entry["path_display"] + "/")
+    return result
 
 
-def read_dropbox(dropbox_path, max_retries=100):
+def read_dropbox(dropbox_path):
     """
     read_dropbox
 
@@ -183,9 +169,6 @@ def read_dropbox(dropbox_path, max_retries=100):
     dropbox_path : str or Pathlib.Path
         path to read from
 
-    max_retries : int
-        number of retries (default: 100)
-
     Returns
     -------
     contents of the dropbox file : bytes
@@ -194,18 +177,20 @@ def read_dropbox(dropbox_path, max_retries=100):
     ----
     If REFRESH_TOKEN, APP_KEY and APP_SECRET environment variables are specified,
     it is not necessary to call dropbox_init() prior to any dropbox function.
-
-    As reading from dropbox is very unreliable under pyodide, reading will have to be retried (by default maximum 100 times).
-    The number of retries can be found with read_dropbox.retries.
     """
 
-    _login_dbx()
-    for read_dropbox.retries in range(max_retries + 1):
-        metadata, response = dbx.files_download(dropbox_path)
-        file_content = response.content
-        if len(file_content) == metadata.size:
-            return file_content
-    raise OSError(f"after {max_retries} still no valid response")
+    _login_dropbox()
+    headers = {"Authorization": f"Bearer {_token}", "Dropbox-API-Arg": json.dumps({"path": dropbox_path})}
+    with requests.post("https://content.dropboxapi.com/2/files/download", headers=headers, stream=True, timeout=60) as r:
+        try:
+            r.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            raise FileNotFoundError(f"file {dropbox_path} not found. Original message is {e}") from None
+        chunks = []
+        for chunk in r.iter_content(chunk_size=1024):
+            if chunk:
+                chunks.append(chunk)
+    return b"".join(chunks)
 
 
 def write_dropbox(dropbox_path, contents):
@@ -227,8 +212,36 @@ def write_dropbox(dropbox_path, contents):
     If REFRESH_TOKEN, APP_KEY and APP_SECRET environment variables are specified,
     it is not necessary to call dropbox_init() prior to any dropbox function.
     """
-    _login_dbx()
-    dbx.files_upload(contents, dropbox_path, mode=dropbox.files.WriteMode.overwrite)
+    _login_dropbox()
+    headers = {
+        "Authorization": f"Bearer {_token}",
+        "Dropbox-API-Arg": json.dumps(
+            {
+                "path": dropbox_path,  # Where it will be saved in Dropbox
+                "mode": "overwrite",  # "add" or "overwrite"
+                "autorename": False,
+                "mute": False,
+            }
+        ),
+        "Content-Type": "application/octet-stream",
+    }
+    response = requests.post("https://content.dropboxapi.com/2/files/upload", headers=headers, data=contents)
+    return response
+
+
+def delete_from_dropbox(dropbox_path):
+    _login_dropbox()
+
+    headers = {"Authorization": f"Bearer {_token}", "Content-Type": "application/json"}
+
+    data = {
+        "path": dropbox_path  # Path in Dropbox, starting with /
+    }
+
+    response = requests.post("https://api.dropboxapi.com/2/files/delete_v2", headers=headers, data=json.dumps(data))
+    if response.status_code == 200:
+        return
+    raise FileNotFoundError(f"dropbox file {dropbox_path} not found")
 
 
 def list_local(path, recursive=False, show_files=True, show_folders=False):
@@ -307,6 +320,8 @@ class block:
         self.dict = {}
         self.number_of_rows = number_of_rows
         self.number_of_columns = number_of_columns
+        self._highest_used_row_number = None
+        self._highest_used_column_number = None
 
     def __eq__(self, other):
         if isinstance(other, block):
@@ -489,8 +504,14 @@ class block:
         if value is None:
             if (row, column) in self.dict:
                 del self.dict[row, column]
+                self._highest_used_row_number = None  # invalidate cached value
+                self._highest_used_column_number = None  # invalidate cached value
         else:
             self.dict[row, column] = value
+            if self._highest_used_row_number:
+                self._highest_used_row_number = max(self._highest_used_row_number, row)
+            if self._highest_used_column_number:
+                self._highest_used_column_number = max(self._highest_used_column_number, column)
 
     def __getitem__(self, row_column):
         row, column = row_column
@@ -517,6 +538,7 @@ class block:
     def number_of_rows(self, value):
         if value < 1:
             raise ValueError(f"number_of_rows should be >=1, not {value}")
+        self._highest_used_row_number = None
         self._number_of_rows = value
         for row, column in list(self.dict):
             if row > self._number_of_rows:
@@ -530,6 +552,7 @@ class block:
     def number_of_columns(self, value):
         if value < 1:
             raise ValueError(f"number_of_columns should be >=1, not {value}")
+        self._highest_used_column_number = None
         self._number_of_columns = value
         for row, column in list(self.dict):
             if column > self._number_of_columns:
@@ -537,17 +560,22 @@ class block:
 
     @property
     def highest_used_row_number(self):
-        if self.dict:
-            return max(row for (row, column) in self.dict)
-        else:
-            return 1
+        if not self._highest_used_row_number:
+            if self.dict:
+                self._highest_used_row_number = max(row for (row, column) in self.dict)
+            else:
+                self._highest_used_row_number = 1
+        return self._highest_used_row_number
 
     @property
     def highest_used_column_number(self):
-        if self.dict:
-            return max(column for (row, column) in self.dict)
-        else:
-            return 1
+        if not self._highest_used_column_number:
+            if self.dict:
+                self._highest_used_column_number = max(column for (row, column) in self.dict)
+            else:
+                self._highest_used_column_number = 1
+
+        return self._highest_used_column_number
 
     def __repr__(self):
         return f"block({self.value})"