unique-sdk 2026.26.0.dev7__tar.gz → 2026.26.0.dev9__tar.gz

{unique_sdk-2026.26.0.dev7 → unique_sdk-2026.26.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.26.0.dev7
+Version: 2026.26.0.dev9
 Summary: 
 Author: Martin Fadler, Konstantin Krauss, Andreas Hauri
 Author-email: Martin Fadler <martin.fadler@unique.ch>, Konstantin Krauss <konstantin@unique.ch>, Andreas Hauri <andreas@unique.ch>

{unique_sdk-2026.26.0.dev7 → unique_sdk-2026.26.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.26.0.dev7"
+version = "2026.26.0.dev9"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }

{unique_sdk-2026.26.0.dev7 → unique_sdk-2026.26.0.dev9}/unique_sdk/__init__.py

@@ -77,6 +77,9 @@ from unique_sdk.api_resources._message import Message as Message
 from unique_sdk.api_resources._integrated import Integrated as Integrated
 from unique_sdk.api_resources._search import Search as Search
 from unique_sdk.api_resources._content import Content as Content
+from unique_sdk.api_resources._dynamic_frontend import (
+    DynamicFrontend as DynamicFrontend,
+)
 from unique_sdk.api_resources._search_string import SearchString as SearchString
 from unique_sdk.api_resources._short_term_memory import (
     ShortTermMemory as ShortTermMemory,

{unique_sdk-2026.26.0.dev7 → unique_sdk-2026.26.0.dev9}/unique_sdk/api_resources/_content.py

@@ -170,6 +170,50 @@ class Content(APIResource["Content"]):
         # a SAS URL the caller PUTs the PDF bytes to. ``file_io.upload_file``
         # exposes this as ``preview_pdf_path`` for a one-call flow.
         previewPdfFileName: NotRequired[str | None]
+        # When true, the platform archives previous blobs for this
+        # content and makes them restorable through the version APIs.
+        versioningEnabled: NotRequired[bool | None]
+
+    class VersionsParams(RequestOptions):
+        contentId: str
+        skip: NotRequired[int | None]
+        take: NotRequired[int | None]
+
+    class ContentVersion(TypedDict):
+        id: str
+        contentId: str
+        versionNumber: int
+        reason: str
+        blobObjectKey: str
+        key: str
+        title: str | None
+        description: str | None
+        url: str | None
+        byteSize: int
+        mimeType: str
+        ownerType: str
+        ownerId: str
+        contentHash: str | None
+        archivedAt: str
+        archivedBy: str | None
+        originalCreatedAt: str
+        originalCreatedBy: str | None
+        createdBy: str | None
+
+    class PaginatedContentVersions(TypedDict):
+        data: list["Content.ContentVersion"]
+        object: str
+
+    class VersionDownloadUrlParams(RequestOptions):
+        contentVersionId: str
+
+    class ContentVersionDownloadUrl(TypedDict):
+        id: str
+        object: str
+        url: str
+
+    class RestoreVersionParams(RequestOptions):
+        contentVersionId: str
 
     class UpdateParams(RequestOptions):
         contentId: NotRequired[str]
@@ -467,6 +511,120 @@ class Content(APIResource["Content"]):
             ),
         )
 
+    @classmethod
+    def versions(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.VersionsParams"],
+    ) -> "Content.PaginatedContentVersions":
+        content_id = params.pop("contentId")
+        return cast(
+            Content.PaginatedContentVersions,
+            cls._static_request(
+                "get",
+                f"/content/{content_id}/versions",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def versions_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.VersionsParams"],
+    ) -> "Content.PaginatedContentVersions":
+        content_id = params.pop("contentId")
+        return cast(
+            Content.PaginatedContentVersions,
+            await cls._static_request_async(
+                "get",
+                f"/content/{content_id}/versions",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def version_download_url(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.VersionDownloadUrlParams"],
+    ) -> "Content.ContentVersionDownloadUrl":
+        content_version_id = params.pop("contentVersionId")
+        return cast(
+            Content.ContentVersionDownloadUrl,
+            cls._static_request(
+                "get",
+                f"/content/versions/{content_version_id}/download-url",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def version_download_url_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.VersionDownloadUrlParams"],
+    ) -> "Content.ContentVersionDownloadUrl":
+        content_version_id = params.pop("contentVersionId")
+        return cast(
+            Content.ContentVersionDownloadUrl,
+            await cls._static_request_async(
+                "get",
+                f"/content/versions/{content_version_id}/download-url",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def restore_version(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.RestoreVersionParams"],
+    ) -> "Content.ContentInfo":
+        content_version_id = params.pop("contentVersionId")
+        return cast(
+            Content.ContentInfo,
+            cls._static_request(
+                "post",
+                f"/content/versions/{content_version_id}/restore",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def restore_version_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Content.RestoreVersionParams"],
+    ) -> "Content.ContentInfo":
+        content_version_id = params.pop("contentVersionId")
+        return cast(
+            Content.ContentInfo,
+            await cls._static_request_async(
+                "post",
+                f"/content/versions/{content_version_id}/restore",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
     @classmethod
     def ingest_magic_table_sheets(
         cls,

unique_sdk-2026.26.0.dev9/unique_sdk/api_resources/_dynamic_frontend.py

@@ -0,0 +1,81 @@
+from typing import Literal, cast
+
+from typing_extensions import NotRequired, Unpack
+
+from unique_sdk._api_resource import APIResource
+from unique_sdk._request_options import RequestOptions
+from unique_sdk._util import classproperty
+
+
+class DynamicFrontend(APIResource["DynamicFrontend"]):
+    @classproperty
+    def OBJECT_NAME(cls) -> Literal["dynamic-frontend"]:
+        return "dynamic-frontend"
+
+    id: str
+    spaceId: str
+    name: str
+    contentId: str
+    status: dict[str, object] | None
+
+    class CreateParams(RequestOptions):
+        name: str
+        contentId: str
+
+    class UpdateParams(RequestOptions):
+        contentId: str
+        name: NotRequired[str | None]
+
+    @classmethod
+    def create(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["DynamicFrontend.CreateParams"],
+    ) -> "DynamicFrontend":
+        return cast(
+            DynamicFrontend,
+            cls._static_request(
+                "post",
+                "/dynamic-frontend",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def modify(
+        cls,
+        space_id: str,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["DynamicFrontend.UpdateParams"],
+    ) -> "DynamicFrontend":
+        return cast(
+            DynamicFrontend,
+            cls._static_request(
+                "patch",
+                f"/dynamic-frontend/{space_id}",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def list(
+        cls,
+        user_id: str,
+        company_id: str,
+    ) -> list["DynamicFrontend"]:
+        response = cls._static_request(
+            "get",
+            "/dynamic-frontend",
+            user_id,
+            company_id,
+        )
+        if isinstance(response, list):
+            return cast(list[DynamicFrontend], response)
+        data = response.get("data", []) if isinstance(response, dict) else []
+        return cast(list[DynamicFrontend], data)

{unique_sdk-2026.26.0.dev7 → unique_sdk-2026.26.0.dev9}/unique_sdk/cli/cli.py

@@ -8,6 +8,10 @@ import click
 
 from unique_sdk.cli import __version__
 from unique_sdk.cli.commands.cite_file import cmd_cite_file
+from unique_sdk.cli.commands.dynamic_frontend import (
+    cmd_dynamic_frontend_deploy,
+    cmd_dynamic_frontend_list,
+)
 from unique_sdk.cli.commands.elicitation import (
     cmd_elicit_ask,
     cmd_elicit_create,
@@ -16,7 +20,14 @@ from unique_sdk.cli.commands.elicitation import (
     cmd_elicit_respond,
     cmd_elicit_wait,
 )
-from unique_sdk.cli.commands.files import cmd_download, cmd_mv_file, cmd_rm, cmd_upload
+from unique_sdk.cli.commands.files import (
+    cmd_download,
+    cmd_mv_file,
+    cmd_restore_version,
+    cmd_rm,
+    cmd_upload,
+    cmd_versions,
+)
 from unique_sdk.cli.commands.folders import cmd_mkdir, cmd_mvdir, cmd_rmdir
 from unique_sdk.cli.commands.mcp import cmd_mcp
 from unique_sdk.cli.commands.navigation import cmd_cd, cmd_ls, cmd_pwd
@@ -53,6 +64,8 @@ from unique_sdk.cli.config import load_config
 from unique_sdk.cli.shell import UniqueShell
 from unique_sdk.cli.state import ShellState
 
+_DYNAMIC_FRONTEND_ERROR_PREFIX = "dynamic-frontend "
+
 MAIN_HELP = """\
 Unique CLI -- Linux-like file explorer for the Unique AI Platform.
 
@@ -85,6 +98,7 @@ Path formats accepted by all commands:
 \b
 File identifiers:
   report.pdf          File name (matched in current directory)
+  /Reports/report.pdf File path (absolute or relative)
   cont_abc123         Content ID (used directly)
 
 \b
@@ -93,12 +107,15 @@ Examples:
   unique-cli ls                     List root folders
   unique-cli ls /Reports            List a specific folder
   unique-cli search "revenue" -l 50 Search with custom limit
-  unique-cli upload ./file.pdf      Upload to current folder
+  unique-cli upload ./file.pdf      Upload versioned to current folder
   unique-cli download cont_abc123   Download by content ID
+  unique-cli versions cont_abc123   List archived file versions
+  unique-cli restore-version cver_1 Restore a file from a version
   unique-cli elicit ask "Which?"    Ask the user a question synchronously
   unique-cli subagent Legal "Review" Invoke a connected space/subagent
   unique-cli web-search search "x"  Search the web via the public API
   unique-cli web-search crawl URL   Crawl a URL via the public API
+  unique-cli dynamic-frontend list  List manageable Dynamic Frontend spaces
 """
 
 
@@ -254,12 +271,13 @@ def mvdir(ctx: click.Context, old_name: str, new_name: str) -> None:
 @click.argument("destination", required=False, default=None)
 @click.pass_context
 def upload(ctx: click.Context, local_path: str, destination: str | None) -> None:
-    """Upload a local file (works like Linux cp).
+    """Upload a local file with versioning enabled (works like Linux cp).
 
     \b
-    Uploads LOCAL_PATH to the Unique platform. DESTINATION works like
-    the target in cp -- it can be a folder path, a new filename, or
-    a combination of both. MIME type is auto-detected.
+    Uploads LOCAL_PATH to the Unique platform with immutable versioning
+    enabled. DESTINATION works like the target in cp -- it can be a
+    folder path, a new filename, or a combination of both. MIME type is
+    auto-detected.
 
     \b
     Destination formats:
@@ -281,6 +299,48 @@ def upload(ctx: click.Context, local_path: str, destination: str | None) -> None
     click.echo(cmd_upload(LazyState.get(ctx), local_path, destination))
 
 
+@main.command()
+@click.argument("name_or_id")
+@click.option("--skip", type=int, default=None, help="Number of versions to skip.")
+@click.option("--take", type=int, default=None, help="Number of versions to return.")
+@click.pass_context
+def versions(
+    ctx: click.Context,
+    name_or_id: str,
+    skip: int | None,
+    take: int | None,
+) -> None:
+    """List archived versions for a file.
+
+    \b
+    NAME_OR_ID is a file path, a file name matched in the current
+    directory, or a content ID (cont_...) which is resolved directly.
+
+    \b
+    Examples:
+      unique-cli versions report.pdf
+      unique-cli versions /Reports/Q1/report.pdf
+      unique-cli versions cont_abc123 --take 10
+    """
+    click.echo(cmd_versions(LazyState.get(ctx), name_or_id, skip=skip, take=take))
+
+
+@main.command(name="restore-version")
+@click.argument("content_version_id")
+@click.pass_context
+def restore_version(ctx: click.Context, content_version_id: str) -> None:
+    """Restore a file from a content version ID.
+
+    \b
+    CONTENT_VERSION_ID is returned by `unique-cli versions`.
+
+    \b
+    Examples:
+      unique-cli restore-version cver_abc123
+    """
+    click.echo(cmd_restore_version(LazyState.get(ctx), content_version_id))
+
+
 @main.command()
 @click.argument("name_or_id")
 @click.argument("local_dest", required=False, default=None)
@@ -289,8 +349,8 @@ def download(ctx: click.Context, name_or_id: str, local_dest: str | None) -> Non
     """Download a file to your local machine.
 
     \b
-    NAME_OR_ID is a file name (matched in the current directory) or
-    a content ID (cont_...) which is resolved directly.
+    NAME_OR_ID is a file path, a file name matched in the current
+    directory, or a content ID (cont_...) which is resolved directly.
 
     \b
     LOCAL_DEST is an optional path (directory or file) to save to.
@@ -299,6 +359,7 @@ def download(ctx: click.Context, name_or_id: str, local_dest: str | None) -> Non
     \b
     Examples:
       unique-cli download annual.pdf
+      unique-cli download /Reports/Q1/annual.pdf
       unique-cli download annual.pdf ./downloads/
       unique-cli download cont_abc123 ~/Desktop/
     """
@@ -324,10 +385,12 @@ def cite(
     \b
     Registers [filesourceN] markers for pages you referenced in your answer.
     Does NOT read or extract the file — use your own tools for that.
+    NAME_OR_ID can be a file path, current-directory file name, or content ID.
 
     \b
     Examples:
       unique-cli cite report.pdf --pages 3,5,7
+      unique-cli cite /Reports/Q1/report.pdf --pages 3,5,7
       unique-cli cite cont_abc123 --pages 1-4
     """
     click.echo(cmd_cite_file(LazyState.get(ctx), name_or_id, pages))
@@ -359,19 +422,92 @@ def read_cmd(ctx: click.Context, cont_id: str) -> None:
     click.echo(output)
 
 
+@main.group(name="dynamic-frontend")
+def dynamic_frontend() -> None:
+    """Deploy and list Dynamic Frontend spaces."""
+
+
+@dynamic_frontend.command(name="deploy")
+@click.option(
+    "--file",
+    "file_path",
+    default=None,
+    type=click.Path(exists=True),
+    help="Path to an upload-ready Dynamic Frontend ZIP bundle.",
+)
+@click.option(
+    "--content-id",
+    default=None,
+    help="Existing Knowledge Base content id for the ZIP bundle.",
+)
+@click.option(
+    "--name",
+    default=None,
+    help="Space display name. Required when creating; optional rename when updating.",
+)
+@click.option(
+    "--space-id", default=None, help="Existing Dynamic Frontend space id to update."
+)
+@click.option(
+    "--json", "output_json", is_flag=True, default=False, help="Print raw JSON."
+)
+@click.pass_context
+def dynamic_frontend_deploy(
+    ctx: click.Context,
+    file_path: str | None,
+    content_id: str | None,
+    name: str | None,
+    space_id: str | None,
+    output_json: bool,
+) -> None:
+    """Create or update a Dynamic Frontend space.
+
+    \b
+    Examples:
+      unique-cli dynamic-frontend deploy --file ./app.zip --name "Revenue Dashboard"
+      unique-cli dynamic-frontend deploy --content-id content_123 --name "Revenue Dashboard"
+      unique-cli dynamic-frontend deploy --space-id assistant_123 --file ./app.zip
+    """
+    output = cmd_dynamic_frontend_deploy(
+        LazyState.get(ctx),
+        file=file_path,
+        content_id=content_id,
+        name=name,
+        space_id=space_id,
+        output_json=output_json,
+    )
+    click.echo(output)
+    if output.startswith(_DYNAMIC_FRONTEND_ERROR_PREFIX):
+        ctx.exit(1)
+
+
+@dynamic_frontend.command(name="list")
+@click.option(
+    "--json", "output_json", is_flag=True, default=False, help="Print raw JSON."
+)
+@click.pass_context
+def dynamic_frontend_list(ctx: click.Context, output_json: bool) -> None:
+    """List Dynamic Frontend spaces the current user can manage."""
+    output = cmd_dynamic_frontend_list(LazyState.get(ctx), output_json=output_json)
+    click.echo(output)
+    if output.startswith(_DYNAMIC_FRONTEND_ERROR_PREFIX):
+        ctx.exit(1)
+
+
 @main.command()
 @click.argument("name_or_id")
 @click.pass_context
 def rm(ctx: click.Context, name_or_id: str) -> None:
-    """Delete a file by name or content ID.
+    """Delete a file by path, name, or content ID.
 
     \b
-    NAME_OR_ID is a file name (matched in the current directory) or
-    a content ID (cont_...).
+    NAME_OR_ID is a file path, a file name matched in the current
+    directory, or a content ID (cont_...).
 
     \b
     Examples:
       unique-cli rm report.pdf
+      unique-cli rm /Reports/Q1/report.pdf
       unique-cli rm cont_abc123
     """
     click.echo(cmd_rm(LazyState.get(ctx), name_or_id))
@@ -386,11 +522,12 @@ def mv(ctx: click.Context, old_name: str, new_name: str) -> None:
 
     \b
     Changes the file's display title without changing its content ID
-    or location. OLD_NAME can be a file name or content ID.
+    or location. OLD_NAME can be a file path, file name, or content ID.
 
     \b
     Examples:
       unique-cli mv annual.pdf annual-2025.pdf
+      unique-cli mv /Reports/Q1/annual.pdf annual-2025.pdf
       unique-cli mv cont_abc123 "New Title.pdf"
     """
     click.echo(cmd_mv_file(LazyState.get(ctx), old_name, new_name))

unique_sdk-2026.26.0.dev9/unique_sdk/cli/commands/dynamic_frontend.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import unique_sdk
+from unique_sdk.cli.state import ShellState
+from unique_sdk.utils.file_io import upload_file
+
+
+def _upload_bundle(state: ShellState, file_path: str) -> str:
+    path = Path(file_path).expanduser().resolve()
+    if not path.is_file():
+        raise ValueError(f"local file not found: {file_path}")
+
+    if not state.scope_id:
+        raise ValueError("cannot upload bundle to root. cd into a folder first.")
+
+    result = upload_file(
+        userId=state.config.user_id,
+        companyId=state.config.company_id,
+        path_to_file=str(path),
+        displayed_filename=path.name,
+        mime_type="application/zip",
+        scope_or_unique_path=state.scope_id,
+    )
+    content_id = getattr(result, "id", None)
+    if not isinstance(content_id, str) or not content_id:
+        raise ValueError("upload did not return a content id")
+    return content_id
+
+
+def _format_space(space: object) -> str:
+    space_id = getattr(space, "spaceId", None) or getattr(space, "id", "")
+    name = getattr(space, "name", "")
+    content_id = getattr(space, "contentId", "")
+    status = getattr(space, "status", None)
+    phase = ""
+    url = ""
+    if isinstance(status, dict):
+        phase = str(status.get("phase") or "")
+        url = str(status.get("url") or "")
+    return "\t".join(
+        part for part in [str(space_id), str(name), str(content_id), phase, url] if part
+    )
+
+
+def cmd_dynamic_frontend_deploy(
+    state: ShellState,
+    *,
+    file: str | None = None,
+    content_id: str | None = None,
+    name: str | None = None,
+    space_id: str | None = None,
+    output_json: bool = False,
+) -> str:
+    try:
+        if not file and not content_id:
+            return "dynamic-frontend deploy: provide either --file or --content-id."
+        if file and content_id:
+            return "dynamic-frontend deploy: --file and --content-id are mutually exclusive."
+        if not space_id and not name:
+            return "dynamic-frontend deploy: provide --name when creating a Dynamic Frontend space."
+
+        resolved_content_id = _upload_bundle(state, file) if file else content_id
+        if not resolved_content_id:
+            return "dynamic-frontend deploy: expected a content id after resolving deploy input."
+
+        if space_id:
+            update_params: unique_sdk.DynamicFrontend.UpdateParams = {
+                "contentId": resolved_content_id,
+            }
+            if name is not None:
+                update_params["name"] = name
+            space = unique_sdk.DynamicFrontend.modify(
+                space_id,
+                user_id=state.config.user_id,
+                company_id=state.config.company_id,
+                **update_params,
+            )
+            action = "Updated"
+        else:
+            space = unique_sdk.DynamicFrontend.create(
+                user_id=state.config.user_id,
+                company_id=state.config.company_id,
+                name=name or "",
+                contentId=resolved_content_id,
+            )
+            action = "Created"
+
+        if output_json:
+            return json.dumps(dict(space), indent=2, default=str)
+
+        space_id_value = getattr(space, "spaceId", None) or getattr(space, "id", "")
+        name_value = getattr(space, "name", name or "")
+        return (
+            f'{action} Dynamic Frontend space "{name_value}" ({space_id_value})\n'
+            f"Content: {resolved_content_id}"
+        )
+    except (ValueError, unique_sdk.APIError, OSError) as e:
+        return f"dynamic-frontend deploy: {e}"
+
+
+def cmd_dynamic_frontend_list(state: ShellState, *, output_json: bool = False) -> str:
+    try:
+        spaces = unique_sdk.DynamicFrontend.list(
+            user_id=state.config.user_id,
+            company_id=state.config.company_id,
+        )
+        if output_json:
+            return json.dumps(spaces, indent=2, default=str)
+        if not spaces:
+            return "No manageable Dynamic Frontend spaces found."
+        return "\n".join(_format_space(space) for space in spaces)
+    except unique_sdk.APIError as e:
+        return f"dynamic-frontend list: {e}"