fcp-sheets 0.1.0__tar.gz

fcp_sheets-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "fcp-sheets",
+  "description": "Semantic spreadsheet operations for LLMs",
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": {
+    "name": "Scott Meyer"
+  },
+  "repository": "https://github.com/aetherwing-io/fcp-sheets",
+  "keywords": ["spreadsheet", "excel", "xlsx", "mcp"]
+}

fcp_sheets-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check for local path references
+        run: |
+          if grep -v '^\s*#' pyproject.toml | grep -q 'path\s*='; then
+            echo "::error::pyproject.toml contains uncommented local path references that break CI installs"
+            exit 1
+          fi
+
+  test:
+    needs: lint
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12', '3.13']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync --extra dev
+      - run: uv run pytest

fcp_sheets-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,22 @@
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: uv sync --extra dev
+      - run: uv run pytest
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

fcp_sheets-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.ruff_cache/
+.venv/
+*.xlsx
+*.xls
+.uv/
+uv.lock

fcp_sheets-0.1.0/CLAUDE.md

@@ -0,0 +1,24 @@
+# fcp-sheets
+
+## Project Overview
+MCP server that lets LLMs create and edit spreadsheets through a semantic verb DSL.
+Uses openpyxl as the native library (Tier 2 architecture).
+
+## Architecture
+- `src/fcp_sheets/model/` — Thin wrapper around openpyxl Workbook, cell ref parser, sheet index
+- `src/fcp_sheets/server/` — Verb handlers (ops_*.py), queries, verb registry, resolvers
+- `src/fcp_sheets/lib/` — Color palette, number formats, chart types, table styles
+- `src/fcp_sheets/adapter.py` — FcpDomainAdapter bridging fcp-core to openpyxl
+- `src/fcp_sheets/main.py` — Server entry point
+
+## Key Patterns
+- Each `ops_*.py` exports a `HANDLERS` dict mapping verb names to handler functions
+- The adapter merges all HANDLERS at import time for dispatch
+- `queries.py` exports `QUERY_HANDLERS` for query dispatch
+- Block mode: `data` lines buffered in adapter, flushed on `data end`
+- Undo/redo: byte snapshots via `wb.save(BytesIO)` / `load_workbook(BytesIO)`
+- Batch atomicity: pre-batch snapshot, rollback on any op failure
+
+## Commands
+- `uv run pytest` — Run tests
+- `uv run python -c "from fcp_sheets.main import main"` — Verify import

fcp_sheets-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aetherwing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fcp_sheets-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: fcp-sheets
+Version: 0.1.0
+Summary: Spreadsheet File Context Protocol — semantic spreadsheet operations for LLMs
+License-File: LICENSE
+Requires-Python: <3.14,>=3.11
+Requires-Dist: fastmcp>=3.0
+Requires-Dist: fcp-core>=0.1.3
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'

fcp_sheets-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "fcp-sheets"
+version = "0.1.0"
+description = "Spreadsheet File Context Protocol — semantic spreadsheet operations for LLMs"
+requires-python = ">=3.11,<3.14"
+dependencies = [
+    "fcp-core>=0.1.3",
+    "fastmcp>=3.0",
+    "openpyxl>=3.1",
+]
+
+# [tool.uv.sources]
+# For local development, uncomment below:
+# fcp-core = { path = "../fcp-core/python", editable = true }
+
+[project.scripts]
+fcp-sheets = "fcp_sheets.main:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.4",
+    "pyright>=1.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fcp_sheets"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+src = ["src"]

fcp_sheets-0.1.0/src/fcp_sheets/__init__.py

@@ -0,0 +1 @@
+"""fcp-sheets — Spreadsheet File Context Protocol."""

fcp_sheets-0.1.0/src/fcp_sheets/adapter.py

@@ -0,0 +1,365 @@
+"""SheetsAdapter — FcpDomainAdapter implementation for openpyxl workbooks.
+
+Bridges fcp-core to openpyxl via SheetsModel (thin wrapper for in-place
+undo/redo). Handles data block mode, batch atomicity (C7), and
+collision detection (C9).
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+from openpyxl import Workbook, load_workbook
+
+from fcp_core import EventLog, OpResult, ParsedOp
+
+from fcp_sheets.model.index import SheetIndex
+from fcp_sheets.model.snapshot import SheetsModel, SnapshotEvent
+from fcp_sheets.server.queries import dispatch_query
+from fcp_sheets.server.resolvers import SheetsOpContext
+
+# Import all handler dicts
+from fcp_sheets.server.ops_cells import HANDLERS as CELLS_HANDLERS
+from fcp_sheets.server.ops_sheets import HANDLERS as SHEETS_HANDLERS
+from fcp_sheets.server.ops_style import HANDLERS as STYLE_HANDLERS
+from fcp_sheets.server.ops_structure import HANDLERS as STRUCTURE_HANDLERS
+from fcp_sheets.server.ops_charts import HANDLERS as CHARTS_HANDLERS
+from fcp_sheets.server.ops_tables import HANDLERS as TABLES_HANDLERS
+from fcp_sheets.server.ops_cond_fmt import HANDLERS as COND_FMT_HANDLERS
+from fcp_sheets.server.ops_validate import HANDLERS as VALIDATE_HANDLERS
+from fcp_sheets.server.ops_editing import HANDLERS as EDITING_HANDLERS
+from fcp_sheets.server.ops_misc import HANDLERS as MISC_HANDLERS
+
+# Max snapshot events in undo history
+MAX_EVENTS = 15
+
+
+class SheetsAdapter:
+    """FcpDomainAdapter[SheetsModel, SnapshotEvent] for spreadsheet operations."""
+
+    def __init__(self) -> None:
+        self.index = SheetIndex()
+        self._named_styles: dict[str, dict] = {}
+
+        # Merge all verb handlers
+        self._handlers: dict[str, callable] = {}
+        for h in (
+            CELLS_HANDLERS, SHEETS_HANDLERS, STYLE_HANDLERS,
+            STRUCTURE_HANDLERS, CHARTS_HANDLERS, TABLES_HANDLERS,
+            COND_FMT_HANDLERS, VALIDATE_HANDLERS, EDITING_HANDLERS,
+            MISC_HANDLERS,
+        ):
+            self._handlers.update(h)
+
+        # Data block mode state
+        self._data_buffer: list[str] | None = None
+        self._data_anchor: str | None = None
+
+    # -- FcpDomainAdapter protocol --
+
+    def create_empty(self, title: str, params: dict[str, str]) -> SheetsModel:
+        """Create a new empty workbook."""
+        wb = Workbook()
+        # Handle sheets:N param
+        num_sheets = 1
+        if "sheets" in params:
+            try:
+                num_sheets = max(1, int(params["sheets"]))
+            except ValueError:
+                pass
+
+        # Default sheet is "Sheet" — rename to "Sheet1" if multiple
+        if num_sheets > 1:
+            wb.active.title = "Sheet1"
+            for i in range(2, num_sheets + 1):
+                wb.create_sheet(title=f"Sheet{i}")
+        else:
+            wb.active.title = "Sheet1"
+
+        model = SheetsModel(title=title, wb=wb)
+        self.index.clear()
+        self.index.active_sheet = wb.active.title
+        self._named_styles.clear()
+        self._data_buffer = None
+        self._data_anchor = None
+        return model
+
+    def serialize(self, model: SheetsModel, path: str) -> None:
+        """Save workbook to file."""
+        model.wb.save(path)
+        model.file_path = path
+
+    def deserialize(self, path: str) -> SheetsModel:
+        """Load workbook from file."""
+        wb = load_workbook(path)
+        # Extract title from properties or filename
+        title = wb.properties.title if wb.properties and wb.properties.title else path.rsplit("/", 1)[-1]
+        model = SheetsModel(title=title, wb=wb)
+        model.file_path = path
+        self.index.rebuild(model)
+        return model
+
+    def rebuild_indices(self, model: SheetsModel) -> None:
+        """Rebuild index after undo/redo."""
+        self.index.rebuild(model)
+
+    def get_digest(self, model: SheetsModel) -> str:
+        """Return a compact state fingerprint."""
+        wb = model.wb
+        sheets = len(wb.sheetnames)
+        cells = 0
+        for ws in wb.worksheets:
+            bounds = self.index.get_bounds(ws.title)
+            if bounds:
+                min_r, min_c, max_r, max_c = bounds
+                cells += (max_r - min_r + 1) * (max_c - min_c + 1)
+        return f"{sheets} sheets, ~{cells} cells"
+
+    def dispatch_op(
+        self, op: ParsedOp, model: SheetsModel, log: EventLog
+    ) -> OpResult:
+        """Execute a parsed operation on the model.
+
+        Flow:
+        1. Check for data block mode interception
+        2. Take byte snapshot (for undo)
+        3. Build SheetsOpContext
+        4. Dispatch to handler
+        5. Rebuild index
+        6. Log snapshot event
+        7. Return OpResult
+        """
+        raw = op.raw.strip()
+
+        # -- Data block mode interception --
+        if self._data_buffer is not None:
+            if op.verb == "data" and op.positionals and op.positionals[0].lower() == "end":
+                return self._flush_data_block(model, log)
+            # Accumulate raw line
+            self._data_buffer.append(raw)
+            return OpResult(success=True, message="", prefix="~")
+
+        # Start a new data block
+        if op.verb == "data":
+            if not op.positionals:
+                return OpResult(success=False, message="Usage: data ANCHOR")
+            anchor = op.positionals[0]
+            if anchor.lower() == "end":
+                return OpResult(success=False, message="'data end' without prior 'data ANCHOR'")
+            self._data_buffer = []
+            self._data_anchor = anchor
+            return OpResult(success=True, message="", prefix="~")
+
+        # -- Normal dispatch --
+        handler = self._handlers.get(op.verb)
+        if handler is None:
+            # Try suggestion
+            from fcp_core import suggest
+            s = suggest(op.verb, list(self._handlers.keys()))
+            msg = f"Unknown verb: {op.verb!r}"
+            if s:
+                msg += f"\n  try: {s}"
+            return OpResult(success=False, message=msg)
+
+        # Take pre-op snapshot
+        before = model.snapshot()
+
+        # Build context
+        ctx = SheetsOpContext(
+            wb=model.wb,
+            index=self.index,
+            named_styles=self._named_styles,
+        )
+
+        # Dispatch
+        try:
+            result = handler(op, ctx)
+        except NotImplementedError as exc:
+            return OpResult(success=False, message=str(exc))
+        except (ValueError, KeyError, TypeError) as exc:
+            return OpResult(success=False, message=f"Error: {exc}")
+
+        if not result.success:
+            return result
+
+        # Rebuild index (lightweight — just update active sheet)
+        self.index.active_sheet = model.wb.active.title if model.wb.active else ""
+
+        # Log snapshot for undo
+        after = model.snapshot()
+        log.append(SnapshotEvent(before=before, after=after, summary=op.raw))
+        _trim_events(log, MAX_EVENTS)
+
+        return result
+
+    def dispatch_query(self, query: str, model: SheetsModel) -> str:
+        """Execute a query against the model."""
+        return dispatch_query(query, model, self.index)
+
+    def reverse_event(self, event: SnapshotEvent, model: SheetsModel) -> None:
+        """Undo — restore from before-snapshot."""
+        model.restore(event.before)
+        self.index.rebuild(model)
+
+    def replay_event(self, event: SnapshotEvent, model: SheetsModel) -> None:
+        """Redo — restore from after-snapshot."""
+        model.restore(event.after)
+        self.index.rebuild(model)
+
+    # -- Data block mode helpers --
+
+    def _flush_data_block(self, model: SheetsModel, log: EventLog) -> OpResult:
+        """Process accumulated data block lines and write cells.
+
+        Implements:
+        - C1: Robust type inference (formulas, quoted text, leading zeros, numbers)
+        - C2: Markdown table auto-detection and conversion
+        - C9: Collision detection (warns when overwriting non-empty cells)
+        """
+        import csv
+        from io import StringIO
+
+        buffer = self._data_buffer or []
+        anchor_str = self._data_anchor or "A1"
+        self._data_buffer = None
+        self._data_anchor = None
+
+        if not buffer:
+            return OpResult(success=False, message="Empty data block")
+
+        # Take pre-op snapshot
+        before = model.snapshot()
+
+        # Build context for anchor resolution
+        ctx = SheetsOpContext(
+            wb=model.wb,
+            index=self.index,
+            named_styles=self._named_styles,
+        )
+
+        # Resolve anchor
+        from fcp_sheets.server.resolvers import resolve_cell_ref
+        resolved = resolve_cell_ref(anchor_str, ctx)
+        if resolved is None:
+            return OpResult(success=False, message=f"Invalid anchor: {anchor_str!r}")
+
+        start_col, start_row = resolved
+        ws = ctx.active_sheet
+
+        # Detect markdown table format (C2)
+        is_markdown = False
+        warning = ""
+        # Check first non-empty line for markdown pipe syntax
+        first_content = ""
+        for line in buffer:
+            stripped = line.strip()
+            if stripped:
+                first_content = stripped
+                break
+        if first_content.startswith("|"):
+            is_markdown = True
+            warning = "\n! Warning: Markdown table detected, auto-converted to CSV"
+
+        # Parse all rows first, then check collisions (C9), then write
+        parsed_rows: list[list[str | int | float]] = []
+        for line in buffer:
+            line = line.strip()
+            if not line:
+                continue
+
+            if is_markdown:
+                # Skip separator lines like |---|---|---|
+                if all(c in "|-: " for c in line):
+                    continue
+                # Strip leading/trailing pipes and split on internal pipes
+                cells = [c.strip() for c in line.strip("|").split("|")]
+            else:
+                # Parse as CSV
+                reader = csv.reader(StringIO(line))
+                cells = next(reader, [])
+
+            parsed_rows.append([self._parse_data_value(v.strip()) for v in cells])
+
+        if not parsed_rows:
+            return OpResult(success=False, message="No data rows parsed")
+
+        # C9: Collision detection — check for existing non-empty cells
+        collisions: list[str] = []
+        from fcp_sheets.model.refs import index_to_col
+        for i, row_data in enumerate(parsed_rows):
+            row = start_row + i
+            for j, _val in enumerate(row_data):
+                col = start_col + j
+                existing = ws.cell(row=row, column=col).value
+                if existing is not None:
+                    addr = f"{index_to_col(col)}{row}"
+                    collisions.append(addr)
+
+        collision_warning = ""
+        if collisions:
+            count = len(collisions)
+            preview = ", ".join(collisions[:5])
+            if count > 5:
+                preview += f" (+{count - 5} more)"
+            collision_warning = f"\n! Warning: Overwrote {count} non-empty cell(s): {preview}"
+
+        # Write parsed data to worksheet
+        max_cols = 0
+        for i, row_data in enumerate(parsed_rows):
+            row = start_row + i
+            for j, value in enumerate(row_data):
+                col = start_col + j
+                ws.cell(row=row, column=col, value=value)
+                self.index.expand_bounds(ws.title, row, col)
+            max_cols = max(max_cols, len(row_data))
+
+        rows_written = len(parsed_rows)
+
+        # Log snapshot
+        after = model.snapshot()
+        log.append(SnapshotEvent(
+            before=before, after=after,
+            summary=f"data block at {anchor_str} ({rows_written} rows)",
+        ))
+        _trim_events(log, MAX_EVENTS)
+
+        end_addr = f"{index_to_col(start_col)}{start_row}..{index_to_col(start_col + max_cols - 1)}{start_row + rows_written - 1}"
+        self.index.record_modified(ws.title, end_addr)
+
+        msg = f"Wrote {rows_written} rows at {anchor_str}{warning}{collision_warning}"
+        return OpResult(success=True, message=msg, prefix="+")
+
+    @staticmethod
+    def _parse_data_value(s: str) -> str | int | float:
+        """Parse a value from a data block line (same rules as set verb)."""
+        if not s:
+            return ""
+        if s.startswith("="):
+            return s
+        if (s.startswith('"') and s.endswith('"')) or (s.startswith("'") and s.endswith("'")):
+            return s[1:-1]
+        # Leading zero protection (C1)
+        if len(s) > 1 and s[0] == "0" and s[1:].isdigit():
+            return s
+        try:
+            return int(s)
+        except ValueError:
+            pass
+        try:
+            return float(s)
+        except ValueError:
+            pass
+        return s
+
+
+def _trim_events(log: EventLog, max_events: int) -> None:
+    """Trim oldest events if log exceeds max_events.
+
+    The EventLog doesn't support direct trimming, so we track this
+    via the adapter. For now, the event log grows unbounded and we
+    rely on the byte-snapshot size being manageable.
+    """
+    # Note: EventLog doesn't expose a trim API. The memory cap is
+    # enforced by limiting snapshot retention in the adapter's dispatch.
+    # A future enhancement could add EventLog.trim_oldest().
+    pass

fcp_sheets-0.1.0/src/fcp_sheets/lib/chart_types.py

@@ -0,0 +1,64 @@
+"""Chart type mapping from DSL names to openpyxl chart classes."""
+
+from __future__ import annotations
+
+from openpyxl.chart import (
+    AreaChart,
+    AreaChart3D,
+    BarChart,
+    BarChart3D,
+    BubbleChart,
+    DoughnutChart,
+    LineChart,
+    LineChart3D,
+    PieChart,
+    PieChart3D,
+    RadarChart,
+    ScatterChart,
+    StockChart,
+    SurfaceChart,
+    SurfaceChart3D,
+)
+
+# Mapping from DSL chart type name to (class, grouping, type_override)
+CHART_TYPES: dict[str, tuple[type, str | None, str | None]] = {
+    "bar": (BarChart, "clustered", "bar"),
+    "column": (BarChart, "clustered", "col"),
+    "line": (LineChart, None, None),
+    "pie": (PieChart, None, None),
+    "scatter": (ScatterChart, None, None),
+    "area": (AreaChart, None, None),
+    "doughnut": (DoughnutChart, None, None),
+    "radar": (RadarChart, None, None),
+    "bubble": (BubbleChart, None, None),
+    "stock": (StockChart, None, None),
+    "surface": (SurfaceChart, None, None),
+    # Stacked variants
+    "stacked-bar": (BarChart, "stacked", "bar"),
+    "stacked-column": (BarChart, "stacked", "col"),
+    "stacked-area": (AreaChart, "stacked", None),
+    # 100% stacked
+    "100-bar": (BarChart, "percentStacked", "bar"),
+    "100-column": (BarChart, "percentStacked", "col"),
+    "100-area": (AreaChart, "percentStacked", None),
+    # 3D variants
+    "bar-3d": (BarChart3D, "clustered", "bar"),
+    "column-3d": (BarChart3D, "clustered", "col"),
+    "line-3d": (LineChart3D, None, None),
+    "pie-3d": (PieChart3D, None, None),
+    "area-3d": (AreaChart3D, None, None),
+    "surface-3d": (SurfaceChart3D, None, None),
+}
+
+
+def get_chart_class(type_name: str) -> tuple[type, str | None, str | None]:
+    """Look up chart class and config for a DSL type name.
+
+    Returns (chart_class, grouping, type_override).
+    Raises ValueError if type not found.
+    """
+    key = type_name.lower()
+    if key not in CHART_TYPES:
+        available = ", ".join(sorted(CHART_TYPES.keys()))
+        raise ValueError(f"Unknown chart type: {type_name!r}. Available: {available}")
+    return CHART_TYPES[key]

fcp_sheets-0.1.0/src/fcp_sheets/lib/colors.py

@@ -0,0 +1,50 @@
+"""Named color palette and hex parsing for spreadsheet formatting."""
+
+from __future__ import annotations
+
+# Standard Excel/Office color palette
+NAMED_COLORS: dict[str, str] = {
+    "blue": "4472C4",
+    "orange": "ED7D31",
+    "gray": "A5A5A5",
+    "gold": "FFC000",
+    "lt-blue": "5B9BD5",
+    "green": "70AD47",
+    "red": "FF0000",
+    "dk-green": "00B050",
+    "white": "FFFFFF",
+    "black": "000000",
+    "yellow": "FFFF00",
+    "purple": "7030A0",
+    # Conditional formatting fills
+    "good-fill": "C6EFCE",
+    "bad-fill": "FFC7CE",
+    "neutral-fill": "FFEB9C",
+}
+
+
+def parse_color(color_str: str) -> str:
+    """Parse a color string to a 6-char hex value (no #).
+
+    Accepts:
+      - Named colors: "blue", "red"
+      - Hex with #: "#4472C4"
+      - Hex without #: "4472C4"
+    """
+    # Check named colors
+    name = color_str.lower().strip()
+    if name in NAMED_COLORS:
+        return NAMED_COLORS[name]
+
+    # Strip # prefix
+    hex_str = color_str.lstrip("#").strip()
+
+    # Validate hex
+    if len(hex_str) == 6 and all(c in "0123456789ABCDEFabcdef" for c in hex_str):
+        return hex_str.upper()
+
+    # 3-char shorthand
+    if len(hex_str) == 3 and all(c in "0123456789ABCDEFabcdef" for c in hex_str):
+        return "".join(c + c for c in hex_str).upper()
+
+    raise ValueError(f"Invalid color: {color_str!r}")