sanityops-cli 0.1.6__tar.gz → 0.1.7__tar.gz

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sanityops-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: CLI tool for static defect inspection of AI logical artifacts
 Project-URL: Homepage, https://sanityops.org
 Project-URL: Documentation, https://sanityops.org
@@ -23,7 +23,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
 Requires-Dist: anyio>=4.0
-Requires-Dist: defect-check
+Requires-Dist: defect-check>=0.0.1
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sanityops-cli"
-version = "0.1.6"
+version = "0.1.7"
 description = "CLI tool for static defect inspection of AI logical artifacts"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -31,7 +31,7 @@ dependencies = [
     "httpx>=0.27",
     "tomli>=2.0",
     "tomli-w>=1.0",
-    "defect-check",
+    "defect-check>=0.0.1",
     "pyyaml>=6.0",
     "sanityops-agent>=0.0.4",
     "anyio>=4.0",

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/src/sanityops_cli/__init__.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 #
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/src/sanityops_cli/defect_checker/markdown_reporter.py

@@ -77,6 +77,40 @@ def _aggregate_cross_defects(cross_results: list[dict]) -> list[dict]:
     return defects
 
 
+def _format_permission_table(defects: list[dict]) -> list[str]:
+    """Generate extended markdown table for QD-PM permission defects.
+
+    Columns: ID | Name | Severity | Description | Action | Permission Side | Duty Side | Fix
+
+    Note: Missing fields display as em dash (—) via _esc_md_cell(None).
+    This differs from terminal renderer which silently omits missing fields.
+    """
+    lines = []
+    lines.append("| ID | Name | Severity | Description | Action | Permission Side | Duty Side | Fix |")
+    lines.append("|---|---|---|---|---|---|---|---|")
+
+    for defect in defects:
+        details = defect.get("details", {})
+        if not isinstance(details, dict):
+            details = {}
+
+        defect_id = _esc_md_cell(defect.get("id") or "unknown-permission-defect")
+        name = _esc_md_cell(defect.get("name"))
+        severity = _esc_md_cell(defect.get("severity"))
+        description = _esc_md_cell(defect.get("description"))
+        action = _esc_md_cell(details.get("action"))
+        permission_side = _esc_md_cell(details.get("permission_side"))
+        duty_side = _esc_md_cell(details.get("duty_side"))
+        fix = _esc_md_cell(defect.get("fix_suggestion"))
+
+        lines.append(
+            f"| {defect_id} | {name} | {severity} | {description} | {action} | "
+            f"{permission_side} | {duty_side} | {fix} |"
+        )
+
+    return lines
+
+
 def _calculate_cross_score(
     defects: list[dict],
     check_level: str,
@@ -188,6 +222,14 @@ def _build_report(
             lines.append("")
             continue
 
+        # Use permission-specific table for QD-PM module.
+        # Renderer also detects via module (primary), category, or ID prefix for consistency.
+        if module == "QD-PM":
+            lines.extend(_format_permission_table(defects))
+            lines.append("")
+            continue
+
+        # Standard defect table for other modules
         lines.append("| ID | Name | Severity | Description | Location | Impact | Fix |")
         lines.append("|---|---|---|---|---|---|---|")
         for defect in defects:

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/src/sanityops_cli/defect_checker/renderer.py

@@ -33,6 +33,7 @@ _MODULE_LABELS: dict[str, str] = {
     "QDT": "Tools",
     "QDP": "Prompts",
     "CROSS": "Cross",
+    "QD-PM": "Permissions",
 }
 
 #: Map module names to singular type labels for panel titles.
@@ -40,6 +41,7 @@ _MODULE_TYPE_LABELS: dict[str, str] = {
     "QDS": "Skill",
     "QDT": "Tool",
     "QDP": "Prompt",
+    "QD-PM": "Permission",
 }
 
 
@@ -147,20 +149,23 @@ class DefectRenderer:
 
     def _render_artifact_groups(self, results: list[dict[str, Any]]) -> None:
         for result in results:
+            module = result.get("module", "")
             title = resolve_artifact_title(result)
             if title is None:
                 continue
             defects = result.get("defects", [])
             if not defects:
                 continue
-            self._render_group(title, defects)
+            self._render_group(title, defects, module=module)
             self.console.print()
 
-    def _render_group(self, label: str, defects: list[dict[str, Any]]) -> None:
+    def _render_group(
+        self, label: str, defects: list[dict[str, Any]], *, module: str = ""
+    ) -> None:
         lines: list[str] = []
         shown = defects[:MAX_DEFECTS_PER_GROUP]
         for defect in shown:
-            lines.append(self._format_defect(defect))
+            lines.append(self._format_defect(defect, module=module))
 
         hidden = len(defects) - len(shown)
         if hidden > 0:
@@ -169,9 +174,27 @@ class DefectRenderer:
         body = "\n".join(lines)
         self.console.print(Panel(body, title=label, border_style="cyan"))
 
-    def _format_defect(self, defect: dict[str, Any]) -> str:
-        severity = defect.get("severity", "NONE")
-        defect_id = defect.get("id") or "defect"
+    def _format_defect(self, defect: dict[str, Any], *, module: str = "") -> str:
+        """Format a defect for terminal display.
+
+        Dispatches to specialized formatter for permission defects.
+
+        Detection priority: module == "QD-PM" > category == "permission" > ID prefix.
+        This is more permissive than markdown_reporter's module-only detection.
+        Rationale: terminal output is per-defect and can adapt based on defect
+        content, while markdown uses module-level table structure. The primary
+        path (module == "QD-PM") is shared; fallbacks handle edge cases where
+        defect metadata is inconsistent. This is intentional design.
+        """
+        # Detect permission defects via module, category, or ID prefix
+        category = defect.get("category") or ""
+        raw_defect_id = defect.get("id") or ""
+        if module == "QD-PM" or category == "permission" or raw_defect_id.startswith("QD-PM"):
+            return self._format_permission_defect(defect)
+
+        # Default formatting for other defect types
+        severity = defect.get("severity") or "NONE"
+        defect_id = raw_defect_id or "defect"
         lines = [f"[bold red]✗ [{severity}] {defect_id}[/]"]
         if defect.get("location"):
             lines.append(f"  [dim]Location[/] : {defect['location']}")
@@ -181,6 +204,51 @@ class DefectRenderer:
             lines.append(f"  [dim]Fix[/]      : {defect['fix_suggestion']}")
         return "\n".join(lines)
 
+    def _format_permission_defect(self, defect: dict[str, Any]) -> str:
+        """Format a QD-PM permission defect with permission-specific fields.
+
+        Shows: name, description, action, permission_side, duty_side from details dict.
+
+        Note: Missing fields are silently omitted (unlike markdown which uses em dash).
+        This is intentional for terminal output compactness.
+        """
+        severity = defect.get("severity") or "NONE"
+        defect_id = defect.get("id") or "unknown-permission-defect"
+        lines = [f"[bold red]✗ [{severity}] {defect_id}[/]"]
+
+        # Name field (for consistency with markdown table)
+        if defect.get("name"):
+            lines.append(f"  [dim]Name[/]     : {defect['name']}")
+
+        # Description field (standard field)
+        if defect.get("description"):
+            lines.append(f"  [dim]Desc[/]     : {defect['description']}")
+
+        # Standard fields
+        if defect.get("location"):
+            lines.append(f"  [dim]Location[/] : {defect['location']}")
+        if defect.get("impact"):
+            lines.append(f"  [dim]Impact[/]   : {defect['impact']}")
+
+        # Permission-specific fields from details dict
+        details = defect.get("details", {})
+        if isinstance(details, dict):
+            action = details.get("action")
+            if action:
+                lines.append(f"  [dim]Action[/]   : {action}")
+            permission_side = details.get("permission_side")
+            if permission_side:
+                lines.append(f"  [dim]Permission[/]: {permission_side}")
+            duty_side = details.get("duty_side")
+            if duty_side:
+                lines.append(f"  [dim]Duty[/]     : {duty_side}")
+
+        # Fix suggestion
+        if defect.get("fix_suggestion"):
+            lines.append(f"  [dim]Fix[/]      : {defect['fix_suggestion']}")
+
+        return "\n".join(lines)
+
     # ------------------------------------------------------------------
     # Footer
     # ------------------------------------------------------------------

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/tests/unit/defect_checker/test_markdown_reporter.py

@@ -319,3 +319,229 @@ class TestCrossArtifactReport:
         assert content.count("## Cross (CROSS)") == 1
         assert "QD-PS-1" in content
         assert "QD-PT-1" in content
+
+
+class TestPermissionReport:
+    """Tests for QD-PM permission defect markdown reporting."""
+
+    def _permission_defect(
+        self,
+        defect_id="QD-PM-1.1",
+        severity="P0",
+        name="Permission overflow",
+        action="read",
+        permission_side="skill -> tool -> params",
+        duty_side="skill -> para.3",
+        fix="Narrow scope",
+    ):
+        """Create a permission defect dict for testing."""
+        return {
+            "id": defect_id,
+            "name": name,
+            "severity": severity,
+            "category": "permission",
+            "description": "Permission exceeds duty boundary",
+            "fix_suggestion": fix,
+            "details": {
+                "action": action,
+                "permission_side": permission_side,
+                "duty_side": duty_side,
+            },
+        }
+
+    def test_permission_module_uses_extended_table(self, tmp_path):
+        """QD-PM defects use extended table with permission columns."""
+        response = _response(
+            results=[
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "defects": [self._permission_defect()],
+                }
+            ]
+        )
+        path = save_markdown_report(response, tmp_path)
+        content = path.read_text(encoding="utf-8")
+        assert "## Permissions (QD-PM)" in content
+        # Extended table header
+        assert "| ID | Name | Severity | Description | Action | Permission Side | Duty Side | Fix |" in content
+        # Data row with permission fields
+        assert "QD-PM-1.1" in content
+        assert "read" in content
+        # Note: `->` is HTML-escaped to `->` by _esc_md_cell
+        assert "skill -> tool -> params" in content
+
+    def test_permission_defect_without_details(self, tmp_path):
+        """Permission defects without details field render with dashes."""
+        response = _response(
+            results=[
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "defects": [
+                        {
+                            "id": "QD-PM-2.1",
+                            "name": "Permission issue",
+                            "severity": "P1",
+                            "category": "permission",
+                            "fix_suggestion": "Fix it",
+                            # No details dict
+                        }
+                    ],
+                }
+            ]
+        )
+        path = save_markdown_report(response, tmp_path)
+        content = path.read_text(encoding="utf-8")
+        assert "QD-PM-2.1" in content
+        # Should still have extended table header
+        assert "| Action | Permission Side | Duty Side |" in content
+        # Missing fields should show dashes
+        assert "—" in content
+
+    def test_permission_defect_with_empty_details(self, tmp_path):
+        """Permission defects with empty details dict render gracefully."""
+        response = _response(
+            results=[
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "defects": [
+                        {
+                            "id": "QD-PM-3.1",
+                            "name": "Permission issue",
+                            "severity": "P1",
+                            "category": "permission",
+                            "fix_suggestion": "Fix it",
+                            "details": {},  # Empty dict
+                        }
+                    ],
+                }
+            ]
+        )
+        path = save_markdown_report(response, tmp_path)
+        content = path.read_text(encoding="utf-8")
+        assert "QD-PM-3.1" in content
+        # Missing fields should show dashes
+        assert "—" in content
+
+    def test_permission_table_multiple_defects(self, tmp_path):
+        """Permission table handles multiple defects correctly."""
+        response = _response(
+            results=[
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "defects": [
+                        self._permission_defect(
+                            defect_id="QD-PM-1.1",
+                            action="read",
+                            permission_side="skill -> tool -> params.read",
+                        ),
+                        self._permission_defect(
+                            defect_id="QD-PM-1.2",
+                            action="write",
+                            permission_side="skill -> tool -> params.write",
+                        ),
+                    ],
+                }
+            ]
+        )
+        path = save_markdown_report(response, tmp_path)
+        content = path.read_text(encoding="utf-8")
+        assert "QD-PM-1.1" in content
+        assert "QD-PM-1.2" in content
+        assert "read" in content
+        assert "write" in content
+
+    def test_permission_alongside_other_modules(self, tmp_path):
+        """Permission module coexists with other modules in report."""
+        response = _response(
+            results=[
+                {
+                    "module": "QDS",
+                    "status": "completed",
+                    "defects": [_defect(defect_id="QDS-1", severity="P1")],
+                },
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "defects": [self._permission_defect()],
+                },
+            ]
+        )
+        path = save_markdown_report(response, tmp_path)
+        content = path.read_text(encoding="utf-8")
+        # Both modules should appear
+        assert "## Skills (QDS)" in content
+        assert "## Permissions (QD-PM)" in content
+        # QDS should use standard table
+        assert "| Description | Location | Impact |" in content
+        # QD-PM should use extended table
+        assert "| Action | Permission Side | Duty Side |" in content
+
+
+class TestFormatPermissionTable:
+    """Tests for _format_permission_table helper function."""
+
+    def test_formats_single_defect(self):
+        """Formats a single permission defect correctly."""
+        from sanityops_cli.defect_checker.markdown_reporter import _format_permission_table
+
+        defects = [
+            {
+                "id": "QD-PM-1.1",
+                "name": "Permission overflow",
+                "severity": "P0",
+                "fix_suggestion": "Narrow scope",
+                "details": {
+                    "action": "read",
+                    "permission_side": "skill -> tool -> params",
+                    "duty_side": "skill -> para.3",
+                },
+            }
+        ]
+        lines = _format_permission_table(defects)
+        assert len(lines) == 3  # Header + separator + 1 data row
+        assert "QD-PM-1.1" in lines[2]
+        assert "read" in lines[2]
+
+    def test_formats_multiple_defects(self):
+        """Formats multiple permission defects correctly."""
+        from sanityops_cli.defect_checker.markdown_reporter import _format_permission_table
+
+        defects = [
+            {
+                "id": "QD-PM-1.1",
+                "name": "First",
+                "severity": "P0",
+                "details": {"action": "read"},
+            },
+            {
+                "id": "QD-PM-1.2",
+                "name": "Second",
+                "severity": "P1",
+                "details": {"action": "write"},
+            },
+        ]
+        lines = _format_permission_table(defects)
+        assert len(lines) == 4  # Header + separator + 2 data rows
+        assert "read" in lines[2]
+        assert "write" in lines[3]
+
+    def test_handles_missing_details(self):
+        """Handles defects without details dict."""
+        from sanityops_cli.defect_checker.markdown_reporter import _format_permission_table
+
+        defects = [
+            {
+                "id": "QD-PM-1.1",
+                "name": "No details",
+                "severity": "P1",
+                "fix_suggestion": "Fix it",
+                # No details
+            }
+        ]
+        lines = _format_permission_table(defects)
+        assert len(lines) == 3
+        assert "—" in lines[2]  # Missing fields show dash

{sanityops_cli-0.1.6 → sanityops_cli-0.1.7}/tests/unit/defect_checker/test_renderer.py

@@ -308,3 +308,299 @@ class TestResolveArtifactTitle:
 
         result = {"artifacts": [{"id": "skill-1", "name": "morning-report"}]}
         assert resolve_artifact_title(result) is None
+
+
+class TestPermissionDefects:
+    """Tests for QD-PM permission defect rendering."""
+
+    def _permission_defect(
+        self,
+        defect_id="QD-PM-1.1",
+        severity="P0",
+        name="Permission overflow",
+        location="skill.md:15",
+        impact="Excessive read access",
+        fix="Narrow permission scope",
+        action="read",
+        permission_side="skill -> tool -> params",
+        duty_side="skill -> para.3 -> stmt.1",
+    ):
+        """Create a permission defect dict for testing."""
+        return {
+            "id": defect_id,
+            "name": name,
+            "severity": severity,
+            "category": "permission",
+            "description": "Permission exceeds duty boundary",
+            "location": location,
+            "impact": impact,
+            "fix_suggestion": fix,
+            "details": {
+                "action": action,
+                "permission_side": permission_side,
+                "duty_side": duty_side,
+            },
+        }
+
+    def test_qdpm_module_rendered(self):
+        """QD-PM module is rendered with 'Permissions' label."""
+        console = Console(record=True, width=100)
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [self._permission_defect()],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Permissions" in out
+        assert "QD-PM-1.1" in out
+
+    def test_permission_defect_shows_action_field(self):
+        """Permission defects show action field in terminal."""
+        console = Console(record=True, width=100)
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [self._permission_defect(action="write")],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Action" in out
+        assert "write" in out
+
+    def test_permission_defect_shows_permission_side(self):
+        """Permission defects show permission_side field."""
+        console = Console(record=True, width=120)
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [self._permission_defect(permission_side="skill -> tool -> file")],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Permission" in out and "skill -> tool -> file" in out
+
+    def test_permission_defect_shows_duty_side(self):
+        """Permission defects show duty_side field."""
+        console = Console(record=True, width=120)
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [self._permission_defect(duty_side="skill -> para.5")],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Duty" in out and "skill -> para.5" in out
+
+    def test_permission_defect_without_details(self):
+        """Permission defects without details field still render."""
+        console = Console(record=True, width=100)
+        defect = {
+            "id": "QD-PM-2.1",
+            "name": "Permission issue",
+            "severity": "P1",
+            "category": "permission",
+            "description": "desc",
+            "location": "skill.md:20",
+            "impact": "impact",
+            "fix_suggestion": "fix",
+            # No details dict
+        }
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "QD-PM-2.1" in out
+        assert "Location" in out
+
+    def test_permission_defect_with_empty_details(self):
+        """Permission defects with empty details dict render gracefully."""
+        console = Console(record=True, width=100)
+        defect = {
+            "id": "QD-PM-3.1",
+            "name": "Permission issue",
+            "severity": "P1",
+            "category": "permission",
+            "description": "desc",
+            "location": "skill.md:30",
+            "details": {},  # Empty dict
+        }
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "QD-PM-3.1" in out
+        # Should not crash, should show standard fields
+
+    def test_permission_defect_detected_by_id_prefix(self):
+        """Permission defect detected by QD-PM ID prefix even with different module.
+
+        This tests the ID prefix fallback detection path.
+        """
+        console = Console(record=True, width=100)
+        defect = {
+            "id": "QD-PM-4.1",  # ID starts with QD-PM
+            "name": "Permission issue",
+            "severity": "P1",
+            "category": "",  # No category
+            "description": "desc",
+            "details": {"action": "read"},
+        }
+        result = _result(
+            [
+                {
+                    "module": "QDS",  # Different module - tests ID prefix detection
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        # Should use permission format due to ID prefix
+        assert "Action" in out
+        assert "read" in out
+
+    def test_permission_defect_detected_by_category(self):
+        """Permission defect detected by category='permission' with non-QD-PM module and ID.
+
+        This tests the category-based fallback detection path.
+        """
+        console = Console(record=True, width=100)
+        defect = {
+            "id": "MISC-1",  # Not QD-PM prefix
+            "name": "Permission issue",
+            "severity": "P1",
+            "category": "permission",  # Category triggers detection
+            "description": "desc",
+            "details": {"action": "write"},
+        }
+        result = _result(
+            [
+                {
+                    "module": "QDT",  # Different module - tests category detection
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        # Should use permission format due to category
+        assert "Action" in out
+        assert "write" in out
+
+    def test_permission_defect_with_none_id_no_crash(self):
+        """Renderer doesn't crash when defect id is None.
+
+        This tests the fix for potential AttributeError when id key exists
+        but value is None.
+        """
+        console = Console(record=True, width=100)
+        defect = {
+            "id": None,  # Explicitly None
+            "name": "Permission issue",
+            "severity": "P1",
+            "category": "permission",
+            "details": {"action": "read"},
+        }
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        # Should not raise AttributeError
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Action" in out
+
+    def test_permission_defect_shows_name_field(self):
+        """Permission defects show name field for consistency with markdown."""
+        console = Console(record=True, width=100)
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [self._permission_defect(name="Permission overflow")],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        assert "Name" in out
+        assert "Permission overflow" in out
+
+    def test_permission_format_used_when_module_is_qdpm(self):
+        """Permission format used when module is QD-PM, even with non-matching ID/category.
+
+        This tests the edge case where module == "QD-PM" but defect ID doesn't start
+        with QD-PM and category is empty - ensuring terminal and markdown stay consistent.
+        """
+        console = Console(record=True, width=100)
+        defect = {
+            "id": "OTHER-1",  # Not QD-PM prefix
+            "name": "Edge case defect",
+            "severity": "P1",
+            "category": "",  # Empty category
+            "details": {"action": "read"},
+        }
+        result = _result(
+            [
+                {
+                    "module": "QD-PM",  # Module is QD-PM
+                    "status": "completed",
+                    "artifacts": [],
+                    "defects": [defect],
+                }
+            ]
+        )
+        DefectRenderer(console).render(result)
+        out = console.export_text()
+        # Should still use permission format due to module == "QD-PM"
+        assert "Action" in out
+        assert "read" in out