athena-python-pptx 0.9.0__tar.gz → 0.10.0__tar.gz

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: athena-python-pptx
-Version: 0.9.0
+Version: 0.10.0
 Summary: Drop-in replacement for python-pptx that connects to PPTX Studio for real-time collaboration
 Project-URL: Homepage, https://github.com/pptx-studio/python-sdk
 Project-URL: Documentation, https://docs.pptx-studio.com/sdk/python
@@ -31,7 +31,6 @@ Requires-Dist: responses>=0.23; extra == 'dev'
 Requires-Dist: ruff>=0.1; extra == 'dev'
 Provides-Extra: e2e
 Requires-Dist: pytest>=7.0; extra == 'e2e'
-Requires-Dist: python-pptx>=0.6.21; extra == 'e2e'
 Provides-Extra: visual
 Requires-Dist: numpy>=1.24; extra == 'visual'
 Requires-Dist: pillow>=10.0; extra == 'visual'

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/docs/API_PARITY_EXCEPTIONS.md

@@ -288,12 +288,18 @@ the iterate-and-rebuild pattern in the v0.1.77 retrospective. None of them
 exist in upstream python-pptx — they're Athena additions and code that uses
 them is *not* portable to stock python-pptx.
 
-### `slide.clear_shapes() -> int`
+### `slide.clear_shapes(*, delete_unmodeled_source_content=False) -> int`
 
-Delete every slide-local shape in one batched `post_commands` call. Returns
-the number of shapes queued for deletion. Targets only slide-local shapes
-(what `slide.shapes` iterates); inherited layout / master placeholders are
-left alone.
+Delete every slide-local shape with one slide-scoped command. Returns the
+number of modeled shapes removed. Unmodeled visual OOXML from the imported
+slide is preserved by default, because Athena not rendering an object is not
+authorization to delete it. Inherited layout / master placeholders and
+slide-level background/notes are left alone.
+
+Pass `delete_unmodeled_source_content=True` only after the user explicitly
+authorizes replacing the complete imported visual layer. That option can
+delete text boxes, SmartArt, controls, and other PowerPoint content that is
+not visible in Athena.
 
 **Why we added it:** the previous workaround was a manual
 `for shape in slide.shapes: shape.delete()` loop. Combined with the silent
@@ -390,6 +396,15 @@ upstream auto-assigns names like `"Rectangle 47"` and only exposes
 construction. **Portable code that needs to run against stock python-pptx
 should omit `name=` and assign after the fact.**
 
+When `name=` is omitted, Athena's generated name skips any identical name in
+the slide's current SDK snapshot. This matters after clone/delete workflows
+where the simple shape-count candidate can already exist. The selected name is
+also available immediately on the returned proxy, before a snapshot refresh.
+This is snapshot-local rather than a distributed uniqueness guarantee: a
+concurrent collaborator can add the same name after the snapshot was loaded.
+Keep the returned proxy or `shape_id` for cross-client-safe follow-up edits;
+use names as human-readable selectors after refreshing the deck.
+
 ```python
 card = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE,
                               Inches(1), Inches(1), Inches(4), Inches(2),
@@ -1049,6 +1064,14 @@ work in addition to SDK surface and are tracked separately.
 
 ### Shape-level additions
 
+- **`Shape.z_order = "to_back" | "to_front" | "backward" | "forward"`**
+  is a write-only convenience alias for `send_to_back()`,
+  `bring_to_front()`, `send_backward()`, and `bring_forward()`. Assignment
+  emits the same `SetShapeZOrder` command as the method form; unsupported
+  strings raise `ValueError` instead of creating a misleading local
+  attribute. Reading `shape.z_order` raises `AttributeError` because deck
+  snapshots do not expose a stable numeric z-order value.
+
 - **`Shape.duplicate(target_slide=None, offset_x=None, offset_y=None)`**
   (closes python-pptx#533, #620, 10-comment thread requesting a public
   duplicate API). Alias for the existing `Shape.clone()` — both verbs

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/pptx/__init__.py

@@ -133,7 +133,7 @@ def flush_all() -> None:
     _active_buffers[:] = alive
 
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"
 
 __all__ = [
     # Main entry point

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/pptx/batching.py

@@ -18,9 +18,11 @@ from contextlib import contextmanager
 from threading import local
 from typing import TYPE_CHECKING, Any, Generator, Optional
 
+import requests
+
 from . import _ptc
 from .commands import AnyCommand, validate_command
-from .errors import BatchPartialError
+from .errors import BatchPartialError, ValidationError
 from .typing import CommandsResponse
 
 if TYPE_CHECKING:
@@ -390,6 +392,37 @@ class CommandBuffer:
                     return_snapshot=False,
                 )
                 applied += len(chunk)
+        except requests.exceptions.InvalidJSONError as exc:
+            # The request body could not be serialized, so nothing reached
+            # the wire. Restoring the unserializable command(s) would poison
+            # the buffer permanently — every later flush would re-fail on the
+            # same payload — so drop them from the restore and surface a
+            # ValidationError naming what was dropped. (validate_command
+            # rejects NaN/Infinity at add() time; this covers commands whose
+            # payload became unserializable after they were buffered.)
+            unsent = commands[applied:]
+            serializable: list[AnyCommand] = []
+            poisoned: list[AnyCommand] = []
+            for command in unsent:
+                try:
+                    json.dumps(command.to_dict(), allow_nan=False)
+                except (TypeError, ValueError):
+                    poisoned.append(command)
+                else:
+                    serializable.append(command)
+            if not poisoned:
+                self._restore_unsent(unsent)
+                raise
+            self._restore_unsent(serializable)
+            _ptc_emit_end_batch(commands[:applied], is_error=False)
+            _ptc_emit_end_batch(unsent, is_error=True)
+            labels = ", ".join(c.context_label() for c in poisoned)
+            raise ValidationError(
+                f"Dropped {len(poisoned)} buffered command(s) that cannot be "
+                f"serialized to JSON ({labels}). The remaining buffered "
+                f"commands were kept and will be sent on the next flush. "
+                f"Original error: {exc}"
+            ) from exc
         except BatchPartialError as exc:
             # The failing chunk committed its commands before
             # ``failure_index`` server-side; everything in earlier chunks

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/pptx/client.py

@@ -40,7 +40,23 @@ from .typing import (
 from .commands import AnyCommand, validate_command
 
 
-SDK_VERSION = "0.1.0"
+def _resolve_sdk_version() -> str:
+    """Installed package version, matching ``pptx.__version__``.
+
+    Read from importlib.metadata rather than importing ``pptx`` — client.py
+    is imported during ``pptx/__init__`` execution, so importing back would
+    be circular. Falls back to "unknown" for source checkouts that were
+    never pip-installed.
+    """
+    try:
+        from importlib.metadata import version
+
+        return version("athena-python-pptx")
+    except Exception:
+        return "unknown"
+
+
+SDK_VERSION = _resolve_sdk_version()
 SDK_CLIENT_TYPE = "python-sdk"
 
 DEFAULT_TIMEOUT = 30  # seconds

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/pptx/commands.py

@@ -13,6 +13,8 @@ __athena_extension_description__: str = (
 )
 __athena_extension_since__: str = "0.1.0"
 
+import math
+
 from dataclasses import dataclass, field, asdict
 from typing import Any, ClassVar, Optional, Union
 from ._citations import normalize_citation_string
@@ -69,6 +71,23 @@ class Command:
         raise NotImplementedError
 
 
+def _find_non_finite(value: Any, path: str) -> Optional[str]:
+    """Return the JSON path of the first NaN/Infinity in ``value``, if any."""
+    if isinstance(value, float) and not math.isfinite(value):
+        return path
+    if isinstance(value, dict):
+        for key, item in value.items():
+            found = _find_non_finite(item, f"{path}.{key}" if path else str(key))
+            if found is not None:
+                return found
+    elif isinstance(value, (list, tuple)):
+        for i, item in enumerate(value):
+            found = _find_non_finite(item, f"{path}[{i}]")
+            if found is not None:
+                return found
+    return None
+
+
 def validate_command(command: "Command") -> None:
     """Validate ``command``, prefixing any ValidationError with its identity.
 
@@ -77,6 +96,11 @@ def validate_command(command: "Command") -> None:
     call site (batched flush, multi-command POST) that alone can't be traced
     back to a shape or slide. Every SDK-internal validation path goes through
     this wrapper so the error always carries the command context.
+
+    Also rejects NaN/Infinity anywhere in the wire payload: JSON has no
+    encoding for them, so they would otherwise pass ``validate()`` and then
+    blow up requests' JSON encoder at flush time — long after the offending
+    user line — leaving the unserializable command stuck in the buffer.
     """
     try:
         command.validate()
@@ -85,6 +109,15 @@ def validate_command(command: "Command") -> None:
             f"{command.context_label()}: {exc.message}", exc.field
         ) from None
 
+    non_finite_path = _find_non_finite(command.to_dict(), "")
+    if non_finite_path is not None:
+        raise ValidationError(
+            f"{command.context_label()}: value at '{non_finite_path}' is NaN "
+            f"or Infinity, which cannot be sent as JSON. Replace it with a "
+            f"finite number, or None to omit the data point.",
+            non_finite_path,
+        )
+
 
 @dataclass
 class AddTextBox(Command):
@@ -269,6 +302,8 @@ class AddSlide(Command):
     Add a new slide to the presentation.
 
     Args:
+        client_id: Correlation ID for commands that reference the new slide in
+            the same batch.
         index: Position to insert the slide (optional, defaults to end)
         layout_index: Layout template index (optional, fallback when no
             name/path given)
@@ -280,6 +315,7 @@ class AddSlide(Command):
             ``slideLayout{i+1}.xml`` filename numbering).
     """
 
+    client_id: Optional[str] = None
     index: Optional[int] = None
     layout_index: Optional[int] = None
     layout_name: Optional[str] = None
@@ -334,6 +370,22 @@ class DeleteShape(Command):
             raise ValidationError("shape_id is required", "shape_id")
 
 
+@dataclass
+class ClearSlideShapes(Command):
+    """Delete modeled slide-local shapes, preserving source-only OOXML by default."""
+
+    slide_id: SlideId
+    delete_unmodeled_source_content: bool = False
+
+    @property
+    def command_type(self) -> str:
+        return "ClearSlideShapes"
+
+    def validate(self) -> None:
+        if not self.slide_id:
+            raise ValidationError("slide_id is required", "slide_id")
+
+
 @dataclass
 class SetParagraphStyle(Command):
     """
@@ -459,14 +511,34 @@ class SetShapeStyle(Command):
     line_scheme_color: Optional[str] = None
     line_width_emu: Optional[int] = None
     line_dash: Optional[str] = None
+    clear_fill: bool = False
 
     @property
     def command_type(self) -> str:
         return "SetShapeStyle"
 
+    def to_dict(self) -> dict[str, Any]:
+        # The wire format distinguishes "clear the fill" (explicit null) from
+        # "leave unchanged" (field absent), but base to_dict drops None fields.
+        # ``clear_fill`` is a local flag translated into explicit nulls here;
+        # it never rides the wire itself.
+        result = super().to_dict()
+        result.pop("clearFill", None)
+        if self.clear_fill:
+            result["fillColorHex"] = None
+            result["fillSchemeColor"] = None
+        return result
+
     def validate(self) -> None:
         if not self.shape_id:
             raise ValidationError("shape_id is required", "shape_id")
+        if self.clear_fill and (
+            self.fill_color_hex is not None or self.fill_scheme_color is not None
+        ):
+            raise ValidationError(
+                "clear_fill cannot be combined with a fill color",
+                "clear_fill",
+            )
         if self.fill_transparency is not None and not (0.0 <= self.fill_transparency <= 1.0):
             raise ValidationError("fill_transparency must be between 0.0 and 1.0", "fill_transparency")
 
@@ -2702,6 +2774,30 @@ class DeleteTableColumn(Command):
             raise ValidationError("col_index must be >= 0", "col_index")
 
 
+@dataclass
+class DeleteTableRow(Command):
+    """Delete the row at ``row_index`` from an existing table.
+
+    Row axis of :class:`DeleteTableColumn`. Unlike ``SetTableRowCount``
+    (which can only truncate rows from the end), this removes a specific
+    row and shifts later rows up, matching ``Table.remove_row(index)``
+    semantics.
+    """
+
+    shape_id: ShapeId
+    row_index: int
+
+    @property
+    def command_type(self) -> str:
+        return "DeleteTableRow"
+
+    def validate(self) -> None:
+        if not self.shape_id:
+            raise ValidationError("shape_id is required", "shape_id")
+        if self.row_index < 0:
+            raise ValidationError("row_index must be >= 0", "row_index")
+
+
 @dataclass
 class SetPointDataLabelStyle(Command):
     """Per-point data-label override on a series.
@@ -3343,6 +3439,7 @@ AnyCommand = Union[
     AddSlide,
     DeleteSlide,
     DeleteShape,
+    ClearSlideShapes,
     SetParagraphStyle,
     AddShape,
     SetShapeStyle,
@@ -3397,6 +3494,7 @@ AnyCommand = Union[
     InsertTableRow,
     InsertTableColumn,
     DeleteTableColumn,
+    DeleteTableRow,
     SetPointDataLabelStyle,
     SetChartTitlePosition,
     AddChart2016,

athena_python_pptx-0.10.0/pptx/oxml/__init__.py

@@ -0,0 +1,43 @@
+"""Compatibility shim for python-pptx's ``pptx.oxml`` package.
+
+Upstream python-pptx exposes its lxml-backed OOXML layer here. The REST SDK
+has no local XML tree — every mutation is a server command — so the element
+classes and parsers cannot exist. This shim keeps ``import pptx.oxml`` (and
+the very common ``from pptx.oxml.ns import qn``) from crashing an entire
+script at import time: the pure-string helpers in :mod:`pptx.oxml.ns` work
+exactly like upstream, and anything that would need a real XML tree raises
+:class:`~pptx.errors.UnsupportedFeatureError` at the call site with guidance
+instead of ``ModuleNotFoundError`` at the import.
+"""
+
+from __future__ import annotations
+
+__athena_extension_module__: bool = True
+__athena_extension_description__: str = (
+    "pptx.oxml import-compatibility shim (REST-SDK only — no local XML tree)."
+)
+__athena_extension_since__: str = "0.9.2"
+
+from typing import Any, NoReturn
+
+from ..errors import UnsupportedFeatureError
+
+
+def parse_xml(xml: Any) -> NoReturn:
+    """Upstream parses an XML fragment into an lxml element tree."""
+    raise UnsupportedFeatureError(
+        "pptx.oxml.parse_xml",
+        "This SDK is a REST client — there is no local XML tree to parse "
+        "into. Use the documented python-pptx object API (shapes, "
+        "text_frame, table, chart) instead of raw OOXML manipulation.",
+    )
+
+
+def register_element_cls(tag: str, cls: Any) -> NoReturn:
+    """Upstream registers a custom lxml element class for a tag."""
+    raise UnsupportedFeatureError(
+        "pptx.oxml.register_element_cls",
+        "This SDK is a REST client — custom OOXML element classes cannot "
+        "be registered because documents are edited through server "
+        "commands, not a local XML tree.",
+    )

athena_python_pptx-0.10.0/pptx/oxml/ns.py

@@ -0,0 +1,91 @@
+"""OOXML namespace helpers — faithful port of ``pptx.oxml.ns``.
+
+These are pure string utilities with no XML-tree dependency, so they behave
+identically to upstream python-pptx. Namespace map copied verbatim from
+python-pptx 1.0.2.
+"""
+
+from __future__ import annotations
+
+_nsmap: dict[str, str] = {
+    "a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    "ct": "http://schemas.openxmlformats.org/package/2006/content-types",
+    "dc": "http://purl.org/dc/elements/1.1/",
+    "dcmitype": "http://purl.org/dc/dcmitype/",
+    "dcterms": "http://purl.org/dc/terms/",
+    "ep": "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+    "i": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    "m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    "mo": "http://schemas.microsoft.com/office/mac/office/2008/main",
+    "mv": "urn:schemas-microsoft-com:mac:vml",
+    "o": "urn:schemas-microsoft-com:office:office",
+    "p": "http://schemas.openxmlformats.org/presentationml/2006/main",
+    "pd": "http://schemas.openxmlformats.org/drawingml/2006/presentationDrawing",
+    "pic": "http://schemas.openxmlformats.org/drawingml/2006/picture",
+    "pr": "http://schemas.openxmlformats.org/package/2006/relationships",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "sl": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
+    "v": "urn:schemas-microsoft-com:vml",
+    "ve": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "w10": "urn:schemas-microsoft-com:office:word",
+    "wne": "http://schemas.microsoft.com/office/word/2006/wordml",
+    "wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+    "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+}
+
+nsmap = _nsmap
+
+
+class NamespacePrefixedTag(str):
+    """Value object holding a namespace-prefixed tag like ``'a:t'``."""
+
+    def __new__(cls, nstag: str, *args: object) -> "NamespacePrefixedTag":
+        return super().__new__(cls, nstag)
+
+    def __init__(self, nstag: str) -> None:
+        self._pfx, self._local_part = nstag.split(":")
+        self._ns_uri = _nsmap[self._pfx]
+
+    @property
+    def clark_name(self) -> str:
+        return f"{{{self._ns_uri}}}{self._local_part}"
+
+    @property
+    def local_part(self) -> str:
+        return self._local_part
+
+    @property
+    def nsmap(self) -> dict[str, str]:
+        return {self._pfx: self._ns_uri}
+
+    @property
+    def nspfx(self) -> str:
+        return self._pfx
+
+    @property
+    def nsuri(self) -> str:
+        return self._ns_uri
+
+
+def namespaces(*prefixes: str) -> dict[str, str]:
+    """Namespace map containing only the specified prefixes."""
+    return {pfx: _nsmap[pfx] for pfx in prefixes}
+
+
+def nsdecls(*prefixes: str) -> str:
+    """Namespace declarations for the specified prefixes, xmlns-attr form."""
+    return " ".join(f'xmlns:{pfx}="{_nsmap[pfx]}"' for pfx in prefixes)
+
+
+def nsuri(nspfx: str) -> str:
+    """Namespace URI corresponding to ``nspfx``."""
+    return _nsmap[nspfx]
+
+
+def qn(namespace_prefixed_tag: str) -> str:
+    """Clark-notation name for a namespace-prefixed tag, e.g. ``qn('a:t')``."""
+    prefix, local = namespace_prefixed_tag.split(":")
+    return f"{{{_nsmap[prefix]}}}{local}"

{athena_python_pptx-0.9.0 → athena_python_pptx-0.10.0}/pptx/presentation.py

@@ -405,35 +405,48 @@ class Presentation:
     @athena_extension(
         issue=1018,
         since="0.1.81",
-        description="Presentation.open — named factory for re-opening an existing deck for iterative edits.",
+        description=(
+            "Presentation.open — open an existing deck by asset id, or "
+            "upload a local .pptx by path."
+        ),
     )
     def open(
         cls,
-        deck_id: str,
+        source: Optional[Union[str, Path]] = None,
         base_url: Optional[str] = None,
         api_key: Optional[str] = None,
+        name: Optional[str] = None,
+        *,
+        deck_id: Optional[str] = None,
+        path: Optional[Union[str, Path]] = None,
     ) -> Presentation:
-        """Open an existing presentation by ``deck_id`` for iterative edits.
+        """Open an existing deck by asset id, or upload a local file by path.
+
+        Closes python-pptx#1018 — "open a PPT in append mode". Two forms,
+        dispatched on the shape of ``source``:
+
+        * ``Presentation.open("asset_<uuid>")`` — reattach to the
+          server-side asset for iterative edits. Same as
+          ``Presentation(asset_id=...)`` but named to mirror the
+          iterate-and-edit verb, and to read naturally next to
+          ``Presentation.create`` / ``Presentation.upload``.
+        * ``Presentation.open("deck.pptx")`` — upload a local ``.pptx``
+          file (alias for :meth:`upload`, matching python-pptx's
+          ``Presentation(path)`` pattern).
 
-        Closes python-pptx#1018 — "open a PPT in append mode". Upstream
-        python-pptx has ``Presentation(filename)`` which loads + parses
-        an OPC package; the REST SDK has no local OPC, so the equivalent
-        is reattaching to the server-side asset. This is the same call
-        as ``Presentation(deck_id=...)`` but named to mirror the iterate-
-        and-edit verb the upstream issue is filed under, and to read
-        naturally next to ``Presentation.create`` / ``Presentation.upload``.
+        ``deck_id=`` and ``path=`` are accepted as explicit keyword
+        spellings of the two forms for callers that want to bypass the
+        shape-based dispatch.
 
         Args:
-            deck_id: The Athena asset id of the existing deck.
+            source: Athena asset id (``asset_<uuid>`` / legacy
+                ``deck_<id>``) or a local file path.
             base_url: Optional API base URL. Defaults to
                 ``ATHENA_PPTX_BASE_URL`` env var.
             api_key: Optional API key. Defaults to ``ATHENA_PPTX_API_KEY``.
-
-        Returns:
-            Presentation reattached to the server-side deck. New slide
-            adds / shape edits stream straight into the live Y.Doc so
-            collaborators see them in real time — the iterative-edit
-            flow the upstream issue describes.
+            name: Optional presentation name — upload form only.
+            deck_id: Keyword-only explicit id form.
+            path: Keyword-only explicit upload form.
 
         Example:
             prs = Presentation.open("asset_3a93...")
@@ -441,7 +454,26 @@ class Presentation:
                 ... # inspect / edit
             prs.save()  # flush pending commands
         """
-        return cls(deck_id=deck_id, base_url=base_url, api_key=api_key)
+        provided = [v for v in (source, deck_id, path) if v is not None]
+        if len(provided) != 1:
+            raise TypeError(
+                "Presentation.open() takes exactly one source: a positional "
+                "asset id or file path, or one of the deck_id=/path= keywords."
+            )
+        if deck_id is None and path is None:
+            if isinstance(source, str) and _DECK_ID_PATTERN.match(source):
+                deck_id = source
+            else:
+                path = source
+        if deck_id is not None:
+            if name is not None:
+                raise TypeError(
+                    "Presentation.open(name=...) is only valid when uploading "
+                    "a local file; an existing deck already has a name."
+                )
+            return cls(deck_id=deck_id, base_url=base_url, api_key=api_key)
+        assert path is not None
+        return cls.upload(path, base_url=base_url, api_key=api_key, name=name)
 
     @classmethod
     @athena_extension(
@@ -694,45 +726,6 @@ class Presentation:
 
         return cls(deck_id=deck_id, base_url=base_url, api_key=api_key, auto_refresh=wait)
 
-    @classmethod
-    @athena_extension(
-        since="0.1.0",
-        description="Presentation.open — alias for upload().",
-    )
-    def open(
-        cls,
-        path: Union[str, Path],
-        base_url: Optional[str] = None,
-        api_key: Optional[str] = None,
-        name: Optional[str] = None,
-    ) -> Presentation:
-        """
-        Open a local PPTX file by uploading it to the server.
-
-        This is an alias for upload() to match python-pptx's Presentation(path) pattern.
-
-        Args:
-            path: Path to the local PPTX file
-            base_url: Base URL of the API. If not provided, uses ATHENA_PPTX_BASE_URL
-                     environment variable.
-            api_key: Optional API key. If not provided, uses ATHENA_PPTX_API_KEY
-                    environment variable.
-            name: Optional name for the presentation
-
-        Returns:
-            Presentation instance for the uploaded deck
-
-        Example:
-            from pptx import Presentation
-
-            # Using environment variables
-            prs = Presentation.open("my_presentation.pptx")
-
-            # Or with explicit parameters
-            prs = Presentation.open("my_presentation.pptx", base_url="http://localhost:4000")
-        """
-        return cls.upload(path, base_url=base_url, api_key=api_key, name=name)
-
     @property
     @athena_extension(
         since="0.1.0",