sagemaker-ops-cli 0.1.0__py3-none-any.whl

sagemaker_ops/tui.py

@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+from typing import Any
+
+from textual import on
+from textual.binding import Binding
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import DataTable, Footer, Header, RichLog, Static
+
+from sagemaker_ops.aws import (
+    AwsCliError,
+    AwsContext,
+    ProcessingJobView,
+    PipelineExecutionView,
+    build_contexts,
+    format_dt,
+    format_duration,
+    infer_log_source,
+    list_active_pipeline_executions,
+    list_pipeline_steps,
+    list_processing_jobs,
+    tail_step_logs,
+)
+
+
+class BaseSageMakerApp(App[None]):
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+
+    #content {
+        height: 1fr;
+    }
+
+    DataTable {
+        height: 1fr;
+        border: solid $surface;
+    }
+
+    #detail, #logs {
+        height: 1fr;
+        border: solid $surface;
+        padding: 1;
+    }
+
+    #detail {
+        width: 40%;
+    }
+
+    #pipeline-content {
+        height: 1fr;
+    }
+
+    #executions-pane {
+        height: 42%;
+    }
+
+    #bottom-pane {
+        height: 58%;
+    }
+
+    #steps-pane {
+        width: 48%;
+    }
+
+    #logs-pane {
+        width: 52%;
+    }
+    """
+
+    BINDINGS = [
+        ("r", "refresh", "Refresh"),
+        ("q", "quit", "Quit"),
+    ]
+
+    def __init__(
+        self,
+        profiles: tuple[str, ...],
+        region: str | None,
+        all_profiles: bool,
+        refresh_seconds: int,
+    ) -> None:
+        super().__init__()
+        self.profiles = profiles
+        self.region = region
+        self.all_profiles = all_profiles
+        self.refresh_seconds = refresh_seconds
+        self.contexts: list[AwsContext] = []
+
+    def load_contexts(self) -> list[AwsContext]:
+        if not self.contexts:
+            self.contexts = build_contexts(self.profiles, self.region, self.all_profiles)
+        return self.contexts
+
+    def on_mount(self) -> None:
+        self.set_interval(self.refresh_seconds, self.action_refresh)
+        self.action_refresh()
+
+    def show_error(self, exc: Exception) -> None:
+        self.query_one("#status", Static).update(f"[red]{exc}[/red]")
+
+
+class ProcessingJobsApp(BaseSageMakerApp):
+    TITLE = "SageMaker Processing Jobs"
+    BINDINGS = BaseSageMakerApp.BINDINGS + [
+        Binding("left", "previous_job", "Previous", priority=True),
+        Binding("up", "previous_job", "Previous", priority=True),
+        Binding("right", "next_job", "Next", priority=True),
+        Binding("down", "next_job", "Next", priority=True),
+    ]
+
+    def __init__(
+        self,
+        profiles: tuple[str, ...],
+        region: str | None,
+        all_profiles: bool,
+        refresh_seconds: int,
+    ) -> None:
+        super().__init__(profiles, region, all_profiles, refresh_seconds)
+        self.jobs: list[ProcessingJobView] = []
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Static("Loading...", id="status")
+        with Horizontal(id="content"):
+            table = DataTable(id="jobs")
+            table.cursor_type = "row"
+            yield table
+            yield Static("", id="detail")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#jobs", DataTable)
+        table.add_columns("Profile", "Region", "Job", "Status", "Runtime", "Instance", "Created")
+        super().on_mount()
+
+    def action_refresh(self) -> None:
+        try:
+            self.jobs = [job for ctx in self.load_contexts() for job in list_processing_jobs(ctx)]
+            self.render_jobs()
+            self.query_one("#status", Static).update(
+                f"{len(self.jobs)} running processing job(s). Refresh every {self.refresh_seconds}s. "
+                "Use arrows to move, r to refresh, q to quit."
+            )
+        except AwsCliError as exc:
+            self.show_error(exc)
+
+    def action_previous_job(self) -> None:
+        table = self.query_one("#jobs", DataTable)
+        if table.row_count:
+            table.move_cursor(row=max(0, table.cursor_row - 1))
+
+    def action_next_job(self) -> None:
+        table = self.query_one("#jobs", DataTable)
+        if table.row_count:
+            table.move_cursor(row=min(table.row_count - 1, table.cursor_row + 1))
+
+    def render_jobs(self) -> None:
+        table = self.query_one("#jobs", DataTable)
+        table.clear()
+        for index, job in enumerate(self.jobs):
+            instance = job.instance_type
+            if job.instance_count:
+                instance = f"{job.instance_count}x {instance}"
+            table.add_row(
+                job.profile,
+                job.region,
+                job.name,
+                job.status,
+                format_duration(job.started_time or job.creation_time),
+                instance,
+                format_dt(job.creation_time),
+                key=str(index),
+            )
+        self.update_processing_detail(0 if self.jobs else None)
+
+    @on(DataTable.RowHighlighted, "#jobs")
+    def on_job_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        try:
+            self.update_processing_detail(int(str(event.row_key.value)))
+        except (TypeError, ValueError):
+            pass
+
+    def update_processing_detail(self, index: int | None) -> None:
+        detail = self.query_one("#detail", Static)
+        if index is None or index >= len(self.jobs):
+            detail.update("No running processing jobs.")
+            return
+        job = self.jobs[index]
+        detail.update(
+            "\n".join(
+                [
+                    f"[bold]{job.name}[/bold]",
+                    f"Profile: {job.profile}",
+                    f"Region: {job.region}",
+                    f"Status: {job.status}",
+                    f"Created: {format_dt(job.creation_time)}",
+                    f"Started: {format_dt(job.started_time)}",
+                    f"Runtime: {format_duration(job.started_time or job.creation_time)}",
+                    f"Instance: {job.instance_count or ''}x {job.instance_type}".strip(),
+                    f"Role: {job.role_arn}",
+                    f"Arn: {job.arn}",
+                    f"Failure: {job.failure_reason}" if job.failure_reason else "",
+                ]
+            )
+        )
+
+
+class PipelineExecutionsApp(BaseSageMakerApp):
+    TITLE = "SageMaker Pipeline Executions"
+    BINDINGS = BaseSageMakerApp.BINDINGS + [
+        ("left", "focus_executions", "Executions"),
+        ("right", "focus_steps", "Steps"),
+        ("l", "load_logs", "Logs"),
+    ]
+
+    def __init__(
+        self,
+        profiles: tuple[str, ...],
+        region: str | None,
+        all_profiles: bool,
+        refresh_seconds: int,
+        pipeline_name: str | None,
+        recent_hours: int = 3,
+    ) -> None:
+        super().__init__(profiles, region, all_profiles, refresh_seconds)
+        self.pipeline_name = pipeline_name
+        self.recent_hours = recent_hours
+        self.executions: list[tuple[AwsContext, PipelineExecutionView]] = []
+        self.steps: list[dict[str, Any]] = []
+        self.selected_context: AwsContext | None = None
+        self.selected_execution_arn: str | None = None
+        self.loaded_log_step_key: tuple[str, str] | None = None
+        self._rendering_executions = False
+        self._updating_steps = False
+        self._suppress_next_execution_highlight = False
+        self._suppress_next_step_highlight = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Static("Loading...", id="status")
+        with Vertical(id="pipeline-content"):
+            with Vertical(id="executions-pane"):
+                executions = DataTable(id="executions")
+                executions.cursor_type = "row"
+                yield executions
+            with Horizontal(id="bottom-pane"):
+                with Vertical(id="steps-pane"):
+                    steps = DataTable(id="steps")
+                    steps.cursor_type = "row"
+                    yield steps
+                with Vertical(id="logs-pane"):
+                    yield RichLog(id="logs", wrap=True, highlight=True, auto_scroll=False)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        executions = self.query_one("#executions", DataTable)
+        executions.add_columns("Profile", "Region", "Pipeline", "Execution", "Status", "Runtime")
+        steps = self.query_one("#steps", DataTable)
+        steps.add_columns("Step", "Type", "Status", "Runtime", "Failure")
+        super().on_mount()
+
+    def action_refresh(self) -> None:
+        previous_execution_arn = self.selected_execution_arn
+        previous_step_name = self.selected_step_name()
+        try:
+            pairs: list[tuple[AwsContext, PipelineExecutionView]] = []
+            for ctx in self.load_contexts():
+                for execution in list_active_pipeline_executions(
+                    ctx, pipeline_name=self.pipeline_name, recent_hours=self.recent_hours
+                ):
+                    pairs.append((ctx, execution))
+            self.executions = pairs
+            self.render_executions(previous_execution_arn, previous_step_name, preserve_logs=True)
+            self.query_one("#status", Static).update(
+                f"{len(self.executions)} active/recent pipeline execution(s), window={self.recent_hours}h. "
+                "Use left/right to switch panes, arrows to move, l to load failed-step logs."
+            )
+        except AwsCliError as exc:
+            self.show_error(exc)
+
+    def action_focus_executions(self) -> None:
+        self.query_one("#executions", DataTable).focus()
+
+    def action_focus_steps(self) -> None:
+        self.query_one("#steps", DataTable).focus()
+
+    def action_load_logs(self) -> None:
+        self.load_selected_step_logs()
+
+    def render_executions(
+        self,
+        preferred_execution_arn: str | None = None,
+        preferred_step_name: str | None = None,
+        preserve_logs: bool = False,
+    ) -> None:
+        table = self.query_one("#executions", DataTable)
+        selected_index = 0 if self.executions else None
+        self._rendering_executions = True
+        try:
+            table.clear()
+            for index, (_, execution) in enumerate(self.executions):
+                if preferred_execution_arn and execution.execution_arn == preferred_execution_arn:
+                    selected_index = index
+                table.add_row(
+                    execution.profile,
+                    execution.region,
+                    execution.pipeline_name,
+                    execution.display_name or execution.execution_arn.rsplit("/", 1)[-1],
+                    execution.status,
+                    format_duration(execution.start_time),
+                    key=str(index),
+                )
+            if selected_index is not None and table.row_count:
+                self._suppress_next_execution_highlight = True
+                table.move_cursor(row=selected_index, scroll=False)
+        finally:
+            self._rendering_executions = False
+        self.update_steps(selected_index, preferred_step_name=preferred_step_name, preserve_logs=preserve_logs)
+
+    @on(DataTable.RowHighlighted, "#executions")
+    def on_execution_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        if self._rendering_executions or self._suppress_next_execution_highlight:
+            self._suppress_next_execution_highlight = False
+            return
+        try:
+            self.update_steps(int(str(event.row_key.value)))
+        except (TypeError, ValueError):
+            pass
+
+    @on(DataTable.RowHighlighted, "#steps")
+    def on_step_highlighted(self, _: DataTable.RowHighlighted) -> None:
+        if self._updating_steps or self._suppress_next_step_highlight:
+            self._suppress_next_step_highlight = False
+            return
+        if self.loaded_log_step_key == self.selected_step_key():
+            return
+        self.loaded_log_step_key = None
+        self.render_step_failure_or_hint()
+
+    def update_steps(
+        self,
+        index: int | None,
+        preferred_step_name: str | None = None,
+        preserve_logs: bool = False,
+    ) -> None:
+        self.steps = []
+        self.selected_context = None
+        self.selected_execution_arn = None
+        logs = self.query_one("#logs", RichLog)
+        if index is None or index >= len(self.executions):
+            self.query_one("#steps", DataTable).clear()
+            self.loaded_log_step_key = None
+            logs.clear()
+            logs.write(f"No active or recent pipeline executions in the last {self.recent_hours}h.")
+            return
+
+        ctx, execution = self.executions[index]
+        self.selected_context = ctx
+        self.selected_execution_arn = execution.execution_arn
+        try:
+            self.steps = list_pipeline_steps(ctx, execution.execution_arn)
+        except AwsCliError as exc:
+            self.loaded_log_step_key = None
+            logs.clear()
+            logs.write(str(exc))
+            return
+        table = self.query_one("#steps", DataTable)
+        selected_step_index = 0 if self.steps else None
+        self._updating_steps = True
+        try:
+            table.clear()
+            for step_index, step in enumerate(self.steps):
+                if preferred_step_name and step.get("StepName", "") == preferred_step_name:
+                    selected_step_index = step_index
+                table.add_row(
+                    step.get("StepName", ""),
+                    step.get("StepType", ""),
+                    step.get("StepStatus", ""),
+                    format_duration(step.get("StartTime"), step.get("EndTime")),
+                    _shorten(step.get("FailureReason", ""), 80),
+                    key=str(step_index),
+                )
+            if selected_step_index is not None and table.row_count:
+                self._suppress_next_step_highlight = True
+                table.move_cursor(row=selected_step_index, scroll=False)
+        finally:
+            self._updating_steps = False
+        if preserve_logs and self.loaded_log_step_key == self.selected_step_key():
+            return
+        self.loaded_log_step_key = None
+        self.render_step_failure_or_hint()
+
+    def render_step_failure_or_hint(self) -> None:
+        if self.loaded_log_step_key == self.selected_step_key():
+            return
+        logs = self.query_one("#logs", RichLog)
+        logs.clear()
+        step = self.selected_step()
+        if step is None:
+            logs.write("Select a step to view details.")
+            return
+        failure = step.get("FailureReason")
+        if failure:
+            logs.write(f"[bold red]Failure[/bold red] {failure}")
+            source = infer_log_source(step)
+            if source:
+                logs.write("Press l to load CloudWatch log tail.")
+            else:
+                logs.write("This step type has no supported CloudWatch log source yet.")
+            return
+        logs.write(
+            f"{step.get('StepName', '')} {step.get('StepStatus', '')} "
+            f"{format_duration(step.get('StartTime'), step.get('EndTime'))}"
+        )
+
+    def load_selected_step_logs(self) -> None:
+        ctx = self.selected_context
+        step = self.selected_step()
+        logs = self.query_one("#logs", RichLog)
+        logs.clear()
+        if ctx is None or step is None:
+            self.loaded_log_step_key = None
+            logs.write("Select a pipeline step first.")
+            return
+        self.loaded_log_step_key = self.selected_step_key()
+        failure = step.get("FailureReason")
+        if failure:
+            logs.write(f"[bold red]Failure[/bold red] {failure}")
+        for line in tail_step_logs(ctx, step):
+            logs.write(line)
+
+    def selected_step(self) -> dict[str, Any] | None:
+        table = self.query_one("#steps", DataTable)
+        if not self.steps or table.cursor_row >= len(self.steps):
+            return None
+        return self.steps[table.cursor_row]
+
+    def selected_step_name(self) -> str | None:
+        step = self.selected_step()
+        if step is None:
+            return None
+        return step.get("StepName", "")
+
+    def selected_step_key(self) -> tuple[str, str] | None:
+        step_name = self.selected_step_name()
+        if not self.selected_execution_arn or not step_name:
+            return None
+        return self.selected_execution_arn, step_name
+
+
+def _shorten(value: str, max_len: int) -> str:
+    if len(value) <= max_len:
+        return value
+    return value[: max_len - 1] + "…"
+

sagemaker_ops_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: sagemaker-ops-cli
+Version: 0.1.0
+Summary: CLI and TUI for submitting and monitoring Amazon SageMaker Processing Jobs and Pipelines.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: botocore>=1.34.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: textual>=0.58.0
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6.0.0; extra == "yaml"
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: moto[logs,sagemaker]>=5.0.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# SageMaker Ops CLI
+
+`smops` 是一个面向 SageMaker Processing Job 和 SageMaker Pipeline 的命令行工具：
+
+- 提交 SageMaker Processing Job
+- 启动 SageMaker Pipeline execution
+- 用 TUI 查看正在运行的 Processing Jobs
+- 用 TUI 查看正在运行和最近结束的 Pipeline executions、steps 状态和失败 step 的 CloudWatch 日志尾部
+- 支持单个、多个或所有 AWS profiles
+
+## 安装
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+从 GitHub 直接安装：
+
+```bash
+pip install git+https://github.com/southpolemonkey/smops.git
+```
+
+从本地 wheel 安装：
+
+```bash
+pip install dist/sagemaker_ops_cli-0.1.0-py3-none-any.whl
+```
+
+如果要读取 YAML 配置:
+
+```bash
+pip install -e '.[yaml]'
+```
+
+## 构建 Python 包
+
+```bash
+pip install -e '.[dev]'
+python -m build
+```
+
+构建产物会输出到 `dist/`：
+
+- `sagemaker_ops_cli-0.1.0-py3-none-any.whl`
+- `sagemaker_ops_cli-0.1.0.tar.gz`
+
+## 提交 Processing Job
+
+配置文件直接使用 boto3 `create_processing_job` 的参数结构。
+
+```bash
+smops processing submit \
+  --profile dev \
+  --region us-east-1 \
+  --config examples/processing-job.json
+```
+
+只检查请求内容，不提交：
+
+```bash
+smops processing submit --config examples/processing-job.json --dry-run
+```
+
+## 启动 Pipeline
+
+```bash
+smops pipeline start \
+  --profile dev \
+  --region us-east-1 \
+  --name my-pipeline \
+  --display-name manual-run-001 \
+  --parameter InputDate=2026-06-30 \
+  --parameter Mode=prod
+```
+
+## TUI 查看 Processing Jobs
+
+```bash
+smops tui processing --profile dev --region us-east-1
+```
+
+多个 profile：
+
+```bash
+smops tui processing --profile dev --profile prod --region us-east-1
+```
+
+所有 profile：
+
+```bash
+smops tui processing --all-profiles
+```
+
+快捷键：
+
+- `↑/↓` 或 `←/→` 切换 job
+- `r` 刷新
+- `q` 退出
+
+## TUI 查看 Pipelines
+
+```bash
+smops tui pipelines --profile dev --region us-east-1
+```
+
+只看某个 pipeline：
+
+```bash
+smops tui pipelines --profile dev --region us-east-1 --name my-pipeline
+```
+
+默认会显示正在运行的 executions，以及最近 3 小时内结束的 executions，方便查看成功/失败结果。可以用 `--hours` 调整窗口：
+
+```bash
+smops tui pipelines --profile dev --region us-east-1 --name my-pipeline --hours 6
+```
+
+快捷键：
+
+- `←/→` 在 executions 和 steps 面板之间切换
+- `↑/↓` 移动当前面板选中行
+- `l` 加载选中失败 step 的 CloudWatch 日志尾部
+- `r` 刷新
+- `q` 退出
+
+目前自动支持这些 step 的日志定位：
+
+- ProcessingJob: `/aws/sagemaker/ProcessingJobs`
+- TrainingJob: `/aws/sagemaker/TrainingJobs`
+- TransformJob: `/aws/sagemaker/TransformJobs`
+
+## 非交互式查看
+
+```bash
+smops processing list --profile dev --region us-east-1
+smops pipeline list --profile dev --region us-east-1
+smops pipeline list --profile dev --region us-east-1 --name my-pipeline --hours 6
+smops pipeline steps --profile dev --region us-east-1 --execution-arn arn:aws:sagemaker:...
+```
+
+`processing list` 默认每页读取 20 个 running jobs。输出 `Next token` 时，用它继续翻页：
+
+```bash
+smops processing list --profile dev --region us-east-1 --max-results 20
+smops processing list --profile dev --region us-east-1 --max-results 20 --next-token '<token>'
+```
+
+`pipeline list` 不传 `--name` 时默认每页只扫描 10 个 pipelines，避免真实账号里 pipelines 很多时卡住。输出 `Next token` 时，用它继续翻页：
+
+```bash
+smops pipeline list --profile dev --region us-east-1 --pipeline-page-size 10
+smops pipeline list --profile dev --region us-east-1 --pipeline-page-size 10 --next-token '<token>'
+```
+
+## AWS 权限
+
+运行账号需要至少具备这些权限：
+
+- `sagemaker:CreateProcessingJob`
+- `sagemaker:StartPipelineExecution`
+- `sagemaker:ListProcessingJobs`
+- `sagemaker:DescribeProcessingJob`
+- `sagemaker:ListPipelines`
+- `sagemaker:ListPipelineExecutions`
+- `sagemaker:DescribePipelineExecution`
+- `sagemaker:ListPipelineExecutionSteps`
+- `logs:DescribeLogStreams`
+- `logs:GetLogEvents`
+
+
+## Mock AWS Profile
+
+仓库里提供了一套 mock AWS 配置，方便本地演示 profile 切换和 CLI 参数解析，不会写入真实 `~/.aws`：
+
+```bash
+export AWS_CONFIG_FILE=examples/aws/config
+export AWS_SHARED_CREDENTIALS_FILE=examples/aws/credentials
+export AWS_PROFILE=mock-dev
+export AWS_DEFAULT_REGION=us-east-1
+```
+
+也可以直接加载样例环境变量：
+
+```bash
+set -a
+source examples/aws/mock.env
+set +a
+```
+
+然后运行：
+
+```bash
+smops processing submit --config examples/processing-job.json --dry-run
+smops processing list --profile mock-dev
+smops tui processing --profile mock-dev
+```
+
+注意：这套 credentials 是 dummy 值，只适合 dry-run、mock、本地端点或配合 botocore Stubber/moto 使用；直接访问真实 AWS 会认证失败。
+
+## E2E 测试
+
+测试使用 `moto` 模拟 AWS SageMaker 和 CloudWatch Logs，不会访问真实 AWS：
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+覆盖范围包括：
+
+- Processing Job 提交和 running job 分页列表
+- Pipeline execution 启动和 active/recent execution 列表
+- Pipeline steps 状态展示
+- 失败 step 的 CloudWatch Logs tail
+- Processing Job TUI 的上下左右键导航
+- Pipeline TUI 的 executions、steps 和失败日志加载
+- 多 AWS profile 解析
+
+Moto 目前还没有实现 `list_pipeline_execution_steps`，测试里对这一个 paginator 做了内存 fake，其余 SageMaker/Logs 调用都在 moto 环境中执行。

sagemaker_ops_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+sagemaker_ops/__init__.py,sha256=cNBPNnVf26SYJQHBnRMAVEN8lsbBqzz-9mubqkdJcXQ,56
+sagemaker_ops/aws.py,sha256=qTW0AVB3JoGqSWxjX0UK-zxyo3DUx-3v7chdVms7zSs,17718
+sagemaker_ops/cli.py,sha256=kYnf7q_eD2qRPgUB2vc1CHpyUbpC-Kg4LECbV9mUfz4,12173
+sagemaker_ops/tui.py,sha256=5aDBxQnF3U3-XmjDUnVhxbLlTy4yXlSdu1z6Rfvng2M,16452
+sagemaker_ops_cli-0.1.0.dist-info/METADATA,sha256=LDQzO25kmo02iCXOOwZGBupfuTJzlpZIPvAw0d6A0iQ,6214
+sagemaker_ops_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sagemaker_ops_cli-0.1.0.dist-info/entry_points.txt,sha256=GwMPaX4XAFwRWaAbot6pSvXtXYc9m5zDj1uWTRFszCA,48
+sagemaker_ops_cli-0.1.0.dist-info/top_level.txt,sha256=2ajnfMn6IWi-PBRpeuatLRUhcLomdOd_s9cmVrX2V9o,14
+sagemaker_ops_cli-0.1.0.dist-info/RECORD,,