snowflake-sandbox-python 0.2.2a2__tar.gz → 0.2.2a3__tar.gz

{snowflake_sandbox_python-0.2.2a2/src/snowflake_sandbox_python.egg-info → snowflake_sandbox_python-0.2.2a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sandbox-python
-Version: 0.2.2a2
+Version: 0.2.2a3
 Summary: Snowflake sandboxes — Python SDK and CLI.
 Author: Snowflake, Inc.
 License: 

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "snowflake-sandbox-python"
-version = "0.2.2a2"
+version = "0.2.2a3"
 description = "Snowflake sandboxes — Python SDK and CLI."
 readme = "README.md"
 requires-python = ">=3.11"

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/_version.py

@@ -29,7 +29,7 @@ __all__ = ["__version__"]
 _DIST_NAME = "snowflake-sandbox-python"
 
 # Keep in sync with [project].version in pyproject.toml.
-_FALLBACK_VERSION = "0.2.2a2"
+_FALLBACK_VERSION = "0.2.2a3"
 
 try:
     __version__: str = _pkg_version(_DIST_NAME)

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/_wire.py

@@ -15,6 +15,7 @@ from collections.abc import Mapping, Sequence
 from datetime import timedelta
 from typing import TYPE_CHECKING, Any, get_args
 
+from snowflake.sandbox._runtime._protocol import _REPLY_SENTINEL, _RESULT_SENTINEL
 from snowflake.sandbox.exceptions import SandboxContractWarning, SandboxError
 from snowflake.sandbox.types import MemoryTier, SandboxStatus
 
@@ -23,6 +24,10 @@ if TYPE_CHECKING:
 
 __all__ = [
     "_parse_status",
+    "_is_internal_sentinel_line",
+    "_visible_log_lines",
+    "_logs_overfetch",
+    "_LOGS_OVERFETCH_CAP",
     "_warn_if_truncated",
     "_exec_session_id",
     "_resolve_exec_budget",
@@ -428,3 +433,58 @@ def _exec_reconnect_exhausted(attempt: int, *, delivered: bool) -> bool:
     never trips this.
     """
     return not delivered and attempt >= len(_EXEC_RECONNECT_DELAYS)
+
+
+# --- internal protocol lines that must never reach a caller's logs() -------------
+#
+# The in-sandbox runner and session daemon report over STDOUT, so their markers land in
+# the log stream alongside the workload's own output: `__SANDBOX_RESULT__<b64>` on
+# managed-process exit and `__SANDBOX_REPLY__<...>` per session reply. They are transport,
+# not output -- `logs()` suppressing them is what LogStream already does for the result
+# marker ("suppress the internal marker from output").
+#
+# They CANNOT be stripped server-side: they are an SDK-level protocol the API knows
+# nothing about, and `_protocol.py` calls their values a compatibility surface (a sandbox
+# launched by an older SDK is still running the older wrapper text), so the wrapper cannot
+# stop printing them either. Internal consumers therefore read the UNFILTERED text via
+# `_logs_raw()`; only the public `logs()` filters.
+_INTERNAL_SENTINELS = (_RESULT_SENTINEL, _REPLY_SENTINEL)
+
+# How many extra lines to ask the server for when a caller wants the last `tail` VISIBLE
+# lines. `tail` is applied SERVER-side, before filtering, so asking for exactly `tail`
+# and then dropping a sentinel returns fewer lines than requested -- the bug that made
+# logs(tail=2) answer ['line5', '__SANDBOX_RESULT__...'] and then, once filtered,
+# ['line5'] alone. The fetch grows until enough visible lines come back, the server runs
+# out of log, or the cap is hit; the cap keeps a session whose recent history is mostly
+# reply markers from turning one logs() call into an unbounded fetch.
+_LOGS_OVERFETCH_MARGIN = 8
+_LOGS_OVERFETCH_CAP = 4096
+
+
+def _is_internal_sentinel_line(text: str) -> bool:
+    """True when a log line carries an SDK-internal protocol marker."""
+    return any(sentinel in text for sentinel in _INTERNAL_SENTINELS)
+
+
+def _visible_log_lines(raw_text: str) -> list[str]:
+    r"""The caller-visible lines of a raw log snapshot, internal markers removed.
+
+    An empty snapshot yields no lines rather than one empty line, so
+    ``"\n".join(...)`` round-trips "" instead of inventing a blank line.
+    """
+    if not raw_text:
+        return []
+    return [ln for ln in raw_text.split("\n") if not _is_internal_sentinel_line(ln)]
+
+
+def _logs_overfetch(tail: int, previous: int = 0) -> int:
+    """Server-side `tail` to request in order to end up with `tail` VISIBLE lines.
+
+    `tail=0` means "everything", which needs no widening. Otherwise start a margin above
+    the request and double on each retry, capped -- see `_LOGS_OVERFETCH_CAP`.
+    """
+    if tail <= 0:
+        return 0
+    if previous <= 0:
+        return tail + _LOGS_OVERFETCH_MARGIN
+    return min(previous * 2, _LOGS_OVERFETCH_CAP)

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/client.py

@@ -57,6 +57,7 @@ from snowflake.sandbox._transport import (
 from snowflake.sandbox._wire import (
     _EXEC_RECONNECT_DELAYS,
     _EXEC_TIMEOUT_GRACE_S,
+    _LOGS_OVERFETCH_CAP,
     _POLL_UNKNOWN_EXIT_CODE,
     _PROBE_BUDGET_S,
     _PROBE_NOT_FOUND_RETRY_S,
@@ -66,8 +67,10 @@ from snowflake.sandbox._wire import (
     _exec_session_id,
     _fresh_exec_body,
     _idle_suspend_minutes,
+    _logs_overfetch,
     _parse_status,
     _resolve_exec_budget,
+    _visible_log_lines,
     _warn_if_truncated,
 )
 from snowflake.sandbox.egress import Egress, compile_egress
@@ -772,10 +775,45 @@ class AsyncSandbox(_FilesMixin, _SandboxState):
         `tail` limits to the last N lines. Only meaningful for command containers
         (created with `command=`).
 
+        SDK-internal protocol markers are suppressed: the in-sandbox runner reports a
+        run's outcome as `__SANDBOX_RESULT__<b64>` on stdout and the session daemon
+        reports replies as `__SANDBOX_REPLY__<...>`, so both land in the log stream
+        beside the workload's own output. They are transport, not output. `tail` counts
+        VISIBLE lines, so `logs(tail=2)` on a command printing `line1..line5` answers the two
+        lines `line4` and `line5`, never spending one of the two on a marker.
+
         Example:
             output = await sb.logs(tail=100)
             print(output)
         """
+        fetch = _logs_overfetch(tail)
+        while True:
+            raw = await self._logs_raw(tail=fetch, since_ts_ms=since_ts_ms)
+            raw_count = len(raw.split("\n")) if raw else 0
+            visible = _visible_log_lines(raw)
+            if tail <= 0 or len(visible) >= tail:
+                break
+            # Short of `tail` visible lines. Only a WIDER fetch can help, and only while
+            # the server still has more to give: `raw_count < fetch` means we already hold
+            # the whole log, so filtering -- not the window -- is why there are fewer.
+            if raw_count < fetch or fetch >= _LOGS_OVERFETCH_CAP:
+                break
+            fetch = _logs_overfetch(tail, fetch)
+        # `tail > 0`, not `if tail`: a NEGATIVE tail is truthy and visible[-(-1):] is
+        # visible[1:], which would silently drop the FIRST lines instead of returning
+        # everything. `_logs_overfetch` already treats tail <= 0 as "no window".
+        if tail > 0:
+            visible = visible[-tail:]
+        return "\n".join(visible)
+
+    async def _logs_raw(self, *, tail: int = 0, since_ts_ms: int = 0) -> str:
+        """The log snapshot EXACTLY as the server returns it, markers included.
+
+        Internal consumers that read the runner's or daemon's stdout protocol
+        (`wait()`, `Job.get`/`Job.status`, `send()`) must use this, not `logs()` --
+        `logs()` strips the very lines they parse. Not public: a caller wanting the
+        sandbox's output wants `logs()`.
+        """
         if not self._created:
             await self._ensure_created()
         if self._id is None:  # pragma: no cover - defensive
@@ -1852,7 +1890,7 @@ class AsyncSandbox(_FilesMixin, _SandboxState):
             # it (the connect() reconnect path) fall through to the server-reported
             # exit code rather than accepting a forgeable, unauthenticated line.
             if self._result_nonce is not None:
-                parsed = _parse_result_sentinel(await self.logs(), nonce=self._result_nonce)
+                parsed = _parse_result_sentinel(await self._logs_raw(), nonce=self._result_nonce)
                 if parsed is not None:
                     parsed.logs_ref = self._id
                     return parsed
@@ -1910,7 +1948,7 @@ class AsyncSandbox(_FilesMixin, _SandboxState):
         await self.exec(_mailbox_append_cmd(msg_id, message))
         deadline = _time.monotonic() + timeout
         while True:
-            reply = _parse_reply_sentinel(await self.logs(), msg_id, nonce=self._reply_nonce)
+            reply = _parse_reply_sentinel(await self._logs_raw(), msg_id, nonce=self._reply_nonce)
             if reply is not None:
                 return reply
             # A terminal container will never reply; surface that rather than spending
@@ -1918,7 +1956,9 @@ class AsyncSandbox(_FilesMixin, _SandboxState):
             # the cached status) is the only live read of the container's lifecycle.
             if await self.refresh() in TERMINAL_STATUSES:
                 # One last read: the daemon may have replied just before exiting.
-                reply = _parse_reply_sentinel(await self.logs(), msg_id, nonce=self._reply_nonce)
+                reply = _parse_reply_sentinel(
+                    await self._logs_raw(), msg_id, nonce=self._reply_nonce
+                )
                 if reply is not None:
                     return reply
                 raise SandboxError(_ended_before_reply(self.status, msg_id))

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/jobs.py

@@ -211,7 +211,7 @@ class Job(_JobHandle):
         terminal state and server-reported exit code, never a forgeable line."""
         sb = await get_sandbox(self.id, connection=self._connection)
         if self.nonce is not None:
-            parsed = _parse_result_sentinel(await sb.logs(), nonce=self.nonce)
+            parsed = _parse_result_sentinel(await sb._logs_raw(), nonce=self.nonce)
             if parsed is not None:
                 # A trusted sentinel reports succeeded/failed; status() is a live
                 # lifecycle verdict where timed_out is not a member, so fold it in.
@@ -226,7 +226,8 @@ class Job(_JobHandle):
     async def get(self, timeout: float | None = None, poll_s: float = 3.0) -> RunResult:
         """Poll for the Job's result.
 
-        Fetches ``get_sandbox(id).logs()`` and scans for the LAST sentinel;
+        Fetches ``get_sandbox(id)._logs_raw()`` -- the UNFILTERED channel, because the
+        public ``logs()`` strips the very sentinel this scans for -- and takes the LAST one;
         returns the decoded `RunResult` as soon as one appears. If the
         container reaches a terminal state (``dead`` or ``failed``) with no sentinel, returns
         ``RunResult(status="failed", ...)``. On *timeout* (when set) before
@@ -239,7 +240,7 @@ class Job(_JobHandle):
             # Only trust the stdout sentinel when we hold the run's nonce;
             # a from_id() handle has none, so fall through to the server state.
             if self.nonce is not None:
-                parsed = _parse_result_sentinel(await sb.logs(), nonce=self.nonce)
+                parsed = _parse_result_sentinel(await sb._logs_raw(), nonce=self.nonce)
                 if parsed is not None:
                     parsed.logs_ref = self.id
                     return parsed
@@ -288,7 +289,7 @@ class SyncJob(_JobHandle):
         container's own terminal state."""
         sb = get_sandbox_sync(self.id, connection=self._connection)
         if self.nonce is not None:
-            parsed = _parse_result_sentinel(sb.logs(), nonce=self.nonce)
+            parsed = _parse_result_sentinel(sb._logs_raw(), nonce=self.nonce)
             if parsed is not None:
                 # See Job.status: fold the non-live timed_out into failed.
                 return "failed" if parsed.status == "timed_out" else parsed.status
@@ -308,7 +309,7 @@ class SyncJob(_JobHandle):
         while True:
             sb = get_sandbox_sync(self.id, connection=self._connection)
             if self.nonce is not None:
-                parsed = _parse_result_sentinel(sb.logs(), nonce=self.nonce)
+                parsed = _parse_result_sentinel(sb._logs_raw(), nonce=self.nonce)
                 if parsed is not None:
                     parsed.logs_ref = self.id
                     return parsed

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/log_stream.py

@@ -24,6 +24,7 @@ from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any, Self
 
 from snowflake.sandbox._runtime._protocol import _RESULT_SENTINEL
+from snowflake.sandbox._wire import _is_internal_sentinel_line
 from snowflake.sandbox.exceptions import SandboxConflictError, SandboxError
 from snowflake.sandbox.types import TERMINAL_STATUSES, StreamName
 
@@ -105,6 +106,13 @@ class LogStream(AsyncIterator[str]):
             if _RESULT_SENTINEL in text:
                 self._process_done = True
                 continue
+            # Any OTHER internal marker (the session daemon's __SANDBOX_REPLY__) is
+            # suppressed too, but is NOT end-of-stream -- a session keeps running after a
+            # reply. Checked after the result marker so that one still sets the flag.
+            # Without this the streamed view leaked a marker the snapshot logs() hides:
+            # same sandbox, two different answers about what its output was.
+            if _is_internal_sentinel_line(text):
+                continue
             ts = int(ln.get("ts") or 0)
             if ts:
                 # Compare against the batch-start watermark, not one mutated

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/sync_client.py

@@ -55,6 +55,7 @@ from snowflake.sandbox._sync_transport import (
 from snowflake.sandbox._wire import (
     _EXEC_RECONNECT_DELAYS,
     _EXEC_TIMEOUT_GRACE_S,
+    _LOGS_OVERFETCH_CAP,
     _POLL_UNKNOWN_EXIT_CODE,
     _PROBE_BUDGET_S,
     _PROBE_NOT_FOUND_RETRY_S,
@@ -64,8 +65,10 @@ from snowflake.sandbox._wire import (
     _exec_session_id,
     _fresh_exec_body,
     _idle_suspend_minutes,
+    _logs_overfetch,
     _parse_status,
     _resolve_exec_budget,
+    _visible_log_lines,
     _warn_if_truncated,
 )
 from snowflake.sandbox.egress import Egress, compile_egress
@@ -771,10 +774,45 @@ class Sandbox(_FilesMixin, _SandboxState):
         `tail` limits to the last N lines. Only meaningful for command containers
         (created with `command=`).
 
+        SDK-internal protocol markers are suppressed: the in-sandbox runner reports a
+        run's outcome as `__SANDBOX_RESULT__<b64>` on stdout and the session daemon
+        reports replies as `__SANDBOX_REPLY__<...>`, so both land in the log stream
+        beside the workload's own output. They are transport, not output. `tail` counts
+        VISIBLE lines, so `logs(tail=2)` on a command printing `line1..line5` answers the two
+        lines `line4` and `line5`, never spending one of the two on a marker.
+
         Example:
             output = sb.logs(tail=100)
             print(output)
         """
+        fetch = _logs_overfetch(tail)
+        while True:
+            raw = self._logs_raw(tail=fetch, since_ts_ms=since_ts_ms)
+            raw_count = len(raw.split("\n")) if raw else 0
+            visible = _visible_log_lines(raw)
+            if tail <= 0 or len(visible) >= tail:
+                break
+            # Short of `tail` visible lines. Only a WIDER fetch can help, and only while
+            # the server still has more to give: `raw_count < fetch` means we already hold
+            # the whole log, so filtering -- not the window -- is why there are fewer.
+            if raw_count < fetch or fetch >= _LOGS_OVERFETCH_CAP:
+                break
+            fetch = _logs_overfetch(tail, fetch)
+        # `tail > 0`, not `if tail`: a NEGATIVE tail is truthy and visible[-(-1):] is
+        # visible[1:], which would silently drop the FIRST lines instead of returning
+        # everything. `_logs_overfetch` already treats tail <= 0 as "no window".
+        if tail > 0:
+            visible = visible[-tail:]
+        return "\n".join(visible)
+
+    def _logs_raw(self, *, tail: int = 0, since_ts_ms: int = 0) -> str:
+        """The log snapshot EXACTLY as the server returns it, markers included.
+
+        Internal consumers that read the runner's or daemon's stdout protocol
+        (`wait()`, `Job.get`/`Job.status`, `send()`) must use this, not `logs()` --
+        `logs()` strips the very lines they parse. Not public: a caller wanting the
+        sandbox's output wants `logs()`.
+        """
         if not self._created:
             self._ensure_created()
         if self._id is None:  # pragma: no cover - defensive
@@ -1801,7 +1839,7 @@ class Sandbox(_FilesMixin, _SandboxState):
             # it (the connect() reconnect path) fall through to the server-reported
             # exit code rather than accepting a forgeable, unauthenticated line.
             if self._result_nonce is not None:
-                parsed = _parse_result_sentinel(self.logs(), nonce=self._result_nonce)
+                parsed = _parse_result_sentinel(self._logs_raw(), nonce=self._result_nonce)
                 if parsed is not None:
                     parsed.logs_ref = self._id
                     return parsed
@@ -1858,7 +1896,7 @@ class Sandbox(_FilesMixin, _SandboxState):
         self.exec(_mailbox_append_cmd(msg_id, message))
         deadline = _time.monotonic() + timeout
         while True:
-            reply = _parse_reply_sentinel(self.logs(), msg_id, nonce=self._reply_nonce)
+            reply = _parse_reply_sentinel(self._logs_raw(), msg_id, nonce=self._reply_nonce)
             if reply is not None:
                 return reply
             # A terminal container will never reply; surface that rather than spending
@@ -1866,7 +1904,7 @@ class Sandbox(_FilesMixin, _SandboxState):
             # the cached status) is the only live read of the container's lifecycle.
             if self.refresh() in TERMINAL_STATUSES:
                 # One last read: the daemon may have replied just before exiting.
-                reply = _parse_reply_sentinel(self.logs(), msg_id, nonce=self._reply_nonce)
+                reply = _parse_reply_sentinel(self._logs_raw(), msg_id, nonce=self._reply_nonce)
                 if reply is not None:
                     return reply
                 raise SandboxError(_ended_before_reply(self.status, msg_id))

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/sync_log_stream.py

@@ -23,6 +23,7 @@ from collections.abc import Iterator
 from typing import TYPE_CHECKING, Self
 
 from snowflake.sandbox._runtime._protocol import _RESULT_SENTINEL
+from snowflake.sandbox._wire import _is_internal_sentinel_line
 from snowflake.sandbox.log_stream import (
     _DRAIN_AFTER_TERMINAL_S,
     _POLL_INTERVAL_S,
@@ -90,6 +91,13 @@ class SyncLogStream(Iterator[str]):
             if _RESULT_SENTINEL in text:
                 self._process_done = True
                 continue
+            # Any OTHER internal marker (the session daemon's __SANDBOX_REPLY__) is
+            # suppressed too, but is NOT end-of-stream -- a session keeps running after a
+            # reply. Checked after the result marker so that one still sets the flag.
+            # Without this the streamed view leaked a marker the snapshot logs() hides:
+            # same sandbox, two different answers about what its output was.
+            if _is_internal_sentinel_line(text):
+                continue
             ts = int(ln.get("ts") or 0)
             if ts:
                 if ts < start_ts:

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3}/src/snowflake/sandbox/warm_session.py

@@ -28,7 +28,8 @@ redeployed, never adopted — see `agent_session`.
 
 * `Session.send()` mints a ``msg_id`` (uuid hex), execs a shell-quoted
   ``printf … >> /var/tmp/sandbox_mailbox.jsonl`` to append the message, then polls
-  ``logs()`` until the matching ``__SANDBOX_REPLY__<msg_id>__<b64>`` line
+  ``_logs_raw()`` -- the UNFILTERED channel, since the public ``logs()`` suppresses
+  internal markers -- until the matching ``__SANDBOX_REPLY__<msg_id>__<b64>`` line
   appears, base64-decodes it, and returns the reply string. A timeout raises
   `SandboxExecTimeoutError`.
 
@@ -304,7 +305,8 @@ class Session:
 
         Mints a ``msg_id``, execs a shell-quoted append into
         ``/var/tmp/sandbox_mailbox.jsonl`` inside the live container, then polls
-        ``logs()`` until the daemon prints ``__SANDBOX_REPLY__<msg_id>__<b64>``.
+        ``_logs_raw()`` (the unfiltered channel; public ``logs()`` hides the marker)
+        until the daemon prints ``__SANDBOX_REPLY__<msg_id>__<b64>``.
         Base64-decodes the payload and returns the reply string.
 
         Raises `SandboxError` if the container reaches a terminal state without
@@ -316,7 +318,7 @@ class Session:
 
         deadline = time.monotonic() + timeout
         while True:
-            log_text = await sb.logs()
+            log_text = await sb._logs_raw()
             reply = _parse_reply_sentinel(log_text, msg_id, nonce=self.nonce)
             if reply is not None:
                 return reply
@@ -327,7 +329,7 @@ class Session:
             if await sb.refresh() in TERMINAL_STATUSES:
                 # One last read first -- the daemon may have replied just before
                 # exiting, and that reply is the answer, not an error.
-                reply = _parse_reply_sentinel(await sb.logs(), msg_id, nonce=self.nonce)
+                reply = _parse_reply_sentinel(await sb._logs_raw(), msg_id, nonce=self.nonce)
                 if reply is not None:
                     return reply
                 raise SandboxError(_ended_before_reply(sb.status, msg_id))
@@ -342,7 +344,8 @@ class Session:
         Same mailbox round-trip as `send`, blocking instead of awaiting: mints a
         ``msg_id``, execs the shell-quoted append into
         ``/var/tmp/sandbox_mailbox.jsonl`` inside the live container (via the
-        synchronous `Sandbox`), then polls ``logs()`` until the daemon prints
+        synchronous `Sandbox`), then polls ``_logs_raw()`` -- the unfiltered channel,
+        since public ``logs()`` hides the marker -- until the daemon prints
         ``__SANDBOX_REPLY__<msg_id>__<b64>``, base64-decodes it, and returns the
         reply string. The request built and the reply parsed are byte-identical
         to `send`'s — both go through the shared ``_mailbox_append_cmd`` /
@@ -365,14 +368,14 @@ class Session:
 
         deadline = time.monotonic() + timeout
         while True:
-            log_text = sb.logs()
+            log_text = sb._logs_raw()
             reply = _parse_reply_sentinel(log_text, msg_id, nonce=self.nonce)
             if reply is not None:
                 return reply
             # As in `send`: a terminal container is not a timeout, and refresh() is
             # the only live read of its status.
             if sb.refresh() in TERMINAL_STATUSES:
-                reply = _parse_reply_sentinel(sb.logs(), msg_id, nonce=self.nonce)
+                reply = _parse_reply_sentinel(sb._logs_raw(), msg_id, nonce=self.nonce)
                 if reply is not None:
                     return reply
                 raise SandboxError(_ended_before_reply(sb.status, msg_id))

{snowflake_sandbox_python-0.2.2a2 → snowflake_sandbox_python-0.2.2a3/src/snowflake_sandbox_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sandbox-python
-Version: 0.2.2a2
+Version: 0.2.2a3
 Summary: Snowflake sandboxes — Python SDK and CLI.
 Author: Snowflake, Inc.
 License: