canvas 0.33.1__tar.gz → 0.34.1__tar.gz

{canvas-0.33.1 → canvas-0.34.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: canvas
-Version: 0.33.1
+Version: 0.34.1
 Summary: SDK to customize event-driven actions in your Canvas instance
 Author-email: Canvas Team <engineering@canvasmedical.com>
 License-Expression: MIT

{canvas-0.33.1 → canvas-0.34.1}/canvas_sdk/utils/http.py

@@ -226,6 +226,31 @@ class Http:
             return [future.result() for future in futures]
 
 
+class JsonOnlyResponse:
+    """
+    A very simple Response analog that only allows access to the json() method
+    and the status_code.
+
+    If we returned the response directly the user could look at the request
+    headers on the response object and see any authentication headers we sent
+    on their behalf.
+    """
+
+    _json: dict[str, Any] | None
+    status_code: int
+
+    def __init__(self, response: requests.Response):
+        self.status_code = response.status_code
+
+        try:
+            self._json = response.json()
+        except Exception:
+            self._json = None
+
+    def json(self) -> dict[str, Any] | None:
+        return self._json
+
+
 class JsonOnlyHttp(Http):
     def get(
         self,
@@ -238,8 +263,8 @@ class JsonOnlyHttp(Http):
         self,
         url: str,
         headers: Mapping[str, str | bytes | None] | None = None,
-    ) -> dict[str, Any]:
-        return super().get(url, headers).json()
+    ) -> JsonOnlyResponse:
+        return JsonOnlyResponse(super().get(url, headers))
 
     def post(
         self,

{canvas-0.33.1 → canvas-0.34.1}/plugin_runner/sandbox.py

@@ -206,6 +206,9 @@ STANDARD_LIBRARY_MODULES = {
         "Type",
         "TypedDict",
     },
+    "urllib": {
+        "parse",
+    },
     "urllib.parse": {
         "urlencode",
         "quote",
@@ -309,6 +312,22 @@ def _find_folder_in_path(file_path: Path, target_folder_name: str) -> Path | Non
     return _find_folder_in_path(file_path.parent, target_folder_name)
 
 
+def node_name(node: ast.AST) -> str:
+    """
+    Given an AST node, return its name.
+    """
+    if isinstance(node, ast.Call):
+        return ".".join(node_name(arg) for arg in node.args)
+
+    if isinstance(node, ast.Constant):
+        return str(node.value)
+
+    if isinstance(node, ast.Name):
+        return str(node.id)
+
+    return "__unknown__"
+
+
 class Sandbox:
     """A restricted sandbox for safely executing arbitrary Python code."""
 
@@ -483,7 +502,7 @@ class Sandbox:
                     func=ast.Name("_write_", ast.Load()),
                     args=[
                         node.value,
-                        ast.Constant(node.value.id if isinstance(node.value, ast.Name) else None),
+                        ast.Constant(node_name(node.value)),
                         ast.Constant(node.attr),
                     ],
                     keywords=[],
@@ -497,6 +516,55 @@ class Sandbox:
                 # Impossible Case only ctx Load, Store and Del are defined in ast.
                 raise NotImplementedError(f"Unknown ctx type: {type(node.ctx)}")
 
+        def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+            """Transforms all kinds of subscripts.
+
+            'foo[bar]' becomes '_getitem_(foo, bar)'
+            'foo[:ab]' becomes '_getitem_(foo, slice(None, ab, None))'
+            'foo[ab:]' becomes '_getitem_(foo, slice(ab, None, None))'
+            'foo[a:b]' becomes '_getitem_(foo, slice(a, b, None))'
+            'foo[a:b:c]' becomes '_getitem_(foo, slice(a, b, c))'
+            'foo[a, b:c] becomes '_getitem_(foo, (a, slice(b, c, None)))'
+            'foo[a] = c' becomes '_write_(foo)[a] = c'
+            'del foo[a]' becomes 'del _write_(foo)[a]'
+
+            The _write_ function should return a security proxy.
+            """
+            node = self.node_contents_visit(node)
+
+            # 'AugStore' and 'AugLoad' are defined in 'Python.asdl' as possible
+            # 'expr_context'. However, according to Python/ast.c
+            # they are NOT used by the implementation => No need to worry here.
+            # Instead ast.c creates 'AugAssign' nodes, which can be visited.
+            if isinstance(node.ctx, ast.Load):
+                new_node = ast.Call(
+                    func=ast.Name("_getitem_", ast.Load()),
+                    args=[node.value, self.transform_slice(node.slice)],
+                    keywords=[],
+                )
+
+                copy_locations(new_node, node)
+
+                return new_node
+            elif isinstance(node.ctx, ast.Del | ast.Store):
+                new_value = ast.Call(
+                    func=ast.Name("_write_", ast.Load()),
+                    args=[
+                        node.value,
+                        ast.Constant(node_name(node.value)),
+                        ast.Constant(node_name(node.slice)),
+                    ],
+                    keywords=[],
+                )
+
+                copy_locations(new_value, node)
+                node.value = new_value
+
+                return node
+            else:  # pragma: no cover
+                # Impossible Case only ctx Load, Store and Del are defined in ast.
+                raise NotImplementedError(f"Unknown ctx type: {type(node.ctx)}")
+
     def __init__(
         self,
         source_code: Path,
@@ -655,7 +723,12 @@ class Sandbox:
         """
         return bool(self.base_path) and module.split(".")[0] == self.package_name
 
-    def _safe_write(self, _ob: Any, name: str | None = None, attribute: str | None = None) -> Any:
+    def _safe_write(
+        self,
+        _ob: Any,
+        name: str | None = None,
+        attribute: str | int | None = None,
+    ) -> Any:
         """Check if the given obj belongs to a protected resource."""
         is_module = isinstance(_ob, types.ModuleType)
 
@@ -664,14 +737,30 @@ class Sandbox:
                 raise AttributeError(f"Forbidden assignment to a module attribute: {_ob.__name__}.")
         elif isinstance(_ob, type):
             full_name = f"{_ob.__module__}.{_ob.__qualname__}"
+            module_name = _ob.__module__
+        else:
+            full_name = f"{_ob.__class__.__module__}.{_ob.__class__.__qualname__}"
+            module_name = _ob.__class__.__module__
+
+        if attribute is not None:
+            if isinstance(_ob, dict):
+                value = dict.get(_ob, attribute)
+            elif isinstance(_ob, list | tuple) and isinstance(attribute, int):
+                value = _ob.__getitem__(attribute)
+            elif isinstance(attribute, str):
+                value = getattr(_ob, attribute, None)
+            else:
+                value = None
         else:
-            full_name = f"{_ob.__module__}.{_ob.__class__.__qualname__}"
+            value = None
 
-        if not self._same_module(_ob.__module__) and (
+        if not self._same_module(module_name) and (
             # deny if it was anything imported
-            name in self.imported_names["names"]
+            (name and name.split(".")[0] in self.imported_names["names"])
             # deny if it's anything callable
-            or (attribute is not None and callable(getattr(_ob, attribute)))
+            or callable(value)
+            # deny writes to dictionary underscore keys
+            or (isinstance(_ob, dict) and isinstance(attribute, str) and attribute.startswith("_"))
         ):
             raise AttributeError(
                 f"Forbidden assignment to a non-module attribute: {full_name} "
@@ -704,7 +793,7 @@ class Sandbox:
         is_module = isinstance(_ob, types.ModuleType)
 
         if is_module:
-            module = _ob.__name__.split(".")[0]
+            module = _ob.__name__
         elif isinstance(_ob, type):
             module = _ob.__module__.split(".")[0]
         else:
@@ -743,7 +832,9 @@ class Sandbox:
             if name not in exports:
                 raise AttributeError(f'"{name}" is an invalid attribute name (not in __exports__)')
         elif is_module and (module not in ALLOWED_MODULES or name not in ALLOWED_MODULES[module]):
-            raise AttributeError(f'"{name}" is an invalid attribute name (not in ALLOWED_MODULES)')
+            raise AttributeError(
+                f'"{module}.{name}" is an invalid attribute name (not in ALLOWED_MODULES)'
+            )
 
         return getattr(_ob, name, default)
 

{canvas-0.33.1 → canvas-0.34.1}/pyproject.toml

@@ -53,7 +53,7 @@ license = "MIT"
 name = "canvas"
 readme = "README.md"
 requires-python = ">=3.11,<3.13"
-version = "0.33.1"
+version = "0.34.1"
 
 [project.scripts]
 canvas = "canvas_cli.main:app"