use pybase64

Author: joocer

opteryx/__version__.py

@@ -1,4 +1,4 @@
-__build__ = 1383
+__build__ = 1384
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

opteryx/functions/string_functions.py

@@ -135,7 +135,7 @@ def get_sha512(item):
 
 def get_base64_encode(item):
     """calculate BASE64 encoding of a string"""
-    import base64
+    import pybase64 as base64
 
     if item is None:
         return None
@@ -147,7 +147,7 @@ def get_base64_encode(item):
 
 def get_base64_decode(item):
     """calculate BASE64 encoding of a string"""
-    import base64
+    import pybase64 as base64
 
     if item is None:
         return None

opteryx/models/relation_statistics.py

@@ -3,9 +3,7 @@
 # See the License at http://www.apache.org/licenses/LICENSE-2.0
 # Distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
 
-import base64
 import decimal
-from base64 import b85decode as _b85decode
 from dataclasses import asdict
 from dataclasses import dataclass
 from dataclasses import field
@@ -17,68 +15,34 @@
 from typing import Tuple
 
 import orjson
+import pybase64 as base64
 
 
 def orjson_default(obj):
     if type(obj) is decimal.Decimal:
         return {"__decimal__": str(obj)}
     if type(obj) is bytes:
-        return {"__bytes__": base64.b85encode(obj).decode("utf-8")}
+        return {"__bytes__": base64.b64encode(obj).decode("utf-8")}
     raise TypeError(f"Type not serializable: {type(obj)}")
 
 
 def decode_object(obj):
-    """
-    Decode an object that was encoded with orjson_default.
-
-    This is part of an optimization path to avoid loading files, so is written to be fast
-    over readability. It uses a stack to traverse the object structure and decode it in place.
-
-    Before this stack-based approach, the recursive version was the third slowest function
-    call in performance tests, so this is a significant improvement.
-    """
-    stack = [(None, None, obj)]  # (parent, key/index, child)
-    root = None
-
-    while stack:
-        parent, key, item = stack.pop()
-
-        t = type(item)
-
-        if t is dict:
-            if "__decimal__" in item:
-                val = _Decimal(item["__decimal__"])
-            elif "__bytes__" in item:
-                val = _b85decode(item["__bytes__"])
-            else:
-                val = {}
-                if parent is not None:
-                    parent[key] = val
-                else:
-                    root = val
-                for k in reversed(list(item.keys())):
-                    stack.append((val, k, item[k]))
-                continue
-
-        elif t is list:
-            val = [None] * len(item)
-            if parent is not None:
-                parent[key] = val
-            else:
-                root = val
-            for i in reversed(range(len(item))):
-                stack.append((val, i, item[i]))
-            continue
-
-        else:
-            val = item
-
-        if parent is not None:
-            parent[key] = val
-        else:
-            root = val
-
-    return root
+    _decode = decode_object
+    t = type(obj)
+
+    if t is dict:
+        if "__decimal__" in obj:
+            return _Decimal(obj["__decimal__"])
+        if "__bytes__" in obj:
+            return base64.b64decode(obj["__bytes__"])
+        return {k: _decode(v) for k, v in obj.items()}
+
+    if t is list:
+        for i, v in enumerate(obj):
+            obj[i] = _decode(v)
+        return obj
+
+    return obj
 
 
 @dataclass

opteryx/planner/sql_rewriter.py

@@ -161,10 +161,10 @@ def sql_parts(string):
             elif part[0] in ("r", "R"):
                 # We take the raw string and encode it, pass it into the
                 # plan as the encoded string and let the engine decode it
-                from base64 import b85encode
+                from pybase64 import b64encode
 
-                encoded_part = b85encode(part[2:-1].encode()).decode()
-                parts.append(f"BASE85_DECODE('{encoded_part}')")
+                encoded_part = b64encode(part[2:-1].encode()).decode()
+                parts.append(f"BASE64_DECODE('{encoded_part}')")
             else:
                 parts.append(part)
         else:

opteryx/third_party/travers/graph.py

@@ -524,22 +524,12 @@ def draw(self, ascii_safe: bool = False) -> str:
 
     def copy(self) -> "Graph":
         """
-        Intelligently make a copy of this Graph, handling situations where Deepcopy
-        does not work.
+        Intelligently make a copy of this Graph, avoiding __init__ and handling
+        deepcopy-resistant structures.
         """
         import copy
 
         def _inner_copy(obj: Any) -> Any:
-            """
-            Create an independent inner copy of the given object.
-
-            Parameters:
-                obj: Any
-                    The object to be deep copied.
-
-            Returns:
-                Any: The new, independent deep copy.
-            """
             obj_type = type(obj)
             if obj_type is list:
                 return [_inner_copy(item) for item in obj]
@@ -553,12 +543,16 @@ def _inner_copy(obj: Any) -> Any:
                 return obj.copy()
             try:
                 return copy.deepcopy(obj)
-            except:
+            except Exception:
                 return obj
 
-        graph = Graph()
+        # Create a new instance without invoking __init__
+        graph = self.__class__.__new__(self.__class__)
+
+        # Manually assign attributes
         graph._nodes = _inner_copy(self._nodes)
         graph._edges = self.copy_edges()
+        graph._cached_edges = None
 
         return graph
 

opteryx/virtual_datasets/astronaut_data.py

@@ -19,6 +19,7 @@
 
 from orso.schema import FlatColumn
 from orso.schema import RelationSchema
+from orso.tools import single_item_cache
 from orso.types import OrsoTypes
 
 from opteryx.models import RelationStatistics
@@ -28,6 +29,7 @@
 _decoded: bytes = None
 
 
+@single_item_cache
 def read(*args):
     import base64
     import io

opteryx/virtual_datasets/missions.py

@@ -15,13 +15,15 @@
 import pyarrow
 from orso.schema import FlatColumn
 from orso.schema import RelationSchema
+from orso.tools import single_item_cache
 from orso.types import OrsoTypes
 
 from opteryx.models import RelationStatistics
 
 __all__ = ("read", "schema")
 
 
+@single_item_cache
 def read(*args) -> pyarrow.Table:
     # Create a PyArrow table with one column and one row
     arrow_schema = pyarrow.schema([pyarrow.field("$column", pyarrow.int64())])

opteryx/virtual_datasets/no_table_data.py

@@ -30,13 +30,15 @@
 import pyarrow
 from orso.schema import FlatColumn
 from orso.schema import RelationSchema
+from orso.tools import single_item_cache
 from orso.types import OrsoTypes
 
 from opteryx.models import RelationStatistics
 
 __all__ = ("read", "schema")
 
 
+@single_item_cache
 def read(end_date=None, *args) -> pyarrow.Table:
     # fmt:off
     # Define the data