rhinoclaw 0.7.0__tar.gz

rhinoclaw-0.7.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: rhinoclaw
+Version: 0.7.0
+Summary: Rhino integration through the Model Context Protocol
+Author-email: Solid AI <info@solid-ai.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/McMuff86/rhinoclaw
+Project-URL: Bug Tracker, https://github.com/McMuff86/rhinoclaw/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=2.11.2
+Requires-Dist: mcp[cli]>=1.12.4
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+
+# RhinoClaw Server
+
+Python MCP server that connects AI agents to Rhino 3D via the Model Context Protocol.
+
+## Overview
+
+This server bridges AI agents (Claude, Cursor, etc.) to Rhino through:
+- **FastMCP**: Python MCP implementation
+- **TCP Socket**: Communication with Rhino plugin on `localhost:1999`
+
+## Installation
+
+```bash
+# Install uv (if not already installed)
+# macOS: brew install uv
+# Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Install dependencies
+cd rhinoclaw_server
+uv pip install -e .
+```
+
+## Usage
+
+```bash
+# Development mode
+uv run python -m rhinoclaw
+
+# Or via uvx (installed)
+uvx rhinoclaw
+```
+
+**Note:** Start the Rhino plugin first (`mcpstart` in Rhino command line).
+
+## Project Structure
+
+```
+rhinoclaw_server/
+├── src/rhinoclaw/
+│   ├── server.py          # Main server, FastMCP setup
+│   ├── tools/             # MCP tool implementations
+│   │   ├── create_object.py
+│   │   ├── modify_object.py
+│   │   ├── get_document_info.py
+│   │   └── ...
+│   ├── utils/             # Helper utilities
+│   └── prompts/           # AI prompts
+├── dev/                   # Development scripts
+│   ├── dev_test.py        # Basic testing
+│   └── dev_castle.py      # Example: castle generation
+└── pyproject.toml         # Package configuration
+```
+
+## Available Tools
+
+For the complete and up-to-date tool list, see [USAGE.md](../docs/USAGE.md).
+
+**Categories:**
+- **System**: ping, get_document_info, get_logs, set_debug_mode
+- **Object Creation**: create_object, create_objects, create_text, create_text_dot
+- **Object Manipulation**: modify_object, delete_object, select_objects, get_object_properties, set_object_properties
+- **Boolean Operations**: boolean_operation (union, difference, intersection)
+- **Transform**: copy_object, mirror_object, array_linear, array_polar
+- **Curves**: offset_curve, fillet_curves, chamfer_curves
+- **Surfaces**: loft_curves, extrude_curve, revolve_curve
+- **Dimensions**: create_linear_dimension, create_angular_dimension, create_radial_dimension
+- **Layers & Materials**: create_layer, create_material, assign_material_to_layer
+- **Scripts**: execute_rhinoscript_python_code
+
+## Development
+
+```bash
+# Run tests
+uv run python dev/dev_test.py
+
+# Build package
+uv build
+
+# Publish to PyPI
+uv publish
+```
+
+## Documentation
+
+- [Main README](../README.md) - Installation and usage
+- [AGENTS.md](../AGENTS.md) - Agent-focused guide
+- [USAGE.md](../docs/USAGE.md) - Tool reference and usage examples

rhinoclaw-0.7.0/README.md

@@ -0,0 +1,87 @@
+# RhinoClaw Server
+
+Python MCP server that connects AI agents to Rhino 3D via the Model Context Protocol.
+
+## Overview
+
+This server bridges AI agents (Claude, Cursor, etc.) to Rhino through:
+- **FastMCP**: Python MCP implementation
+- **TCP Socket**: Communication with Rhino plugin on `localhost:1999`
+
+## Installation
+
+```bash
+# Install uv (if not already installed)
+# macOS: brew install uv
+# Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Install dependencies
+cd rhinoclaw_server
+uv pip install -e .
+```
+
+## Usage
+
+```bash
+# Development mode
+uv run python -m rhinoclaw
+
+# Or via uvx (installed)
+uvx rhinoclaw
+```
+
+**Note:** Start the Rhino plugin first (`mcpstart` in Rhino command line).
+
+## Project Structure
+
+```
+rhinoclaw_server/
+├── src/rhinoclaw/
+│   ├── server.py          # Main server, FastMCP setup
+│   ├── tools/             # MCP tool implementations
+│   │   ├── create_object.py
+│   │   ├── modify_object.py
+│   │   ├── get_document_info.py
+│   │   └── ...
+│   ├── utils/             # Helper utilities
+│   └── prompts/           # AI prompts
+├── dev/                   # Development scripts
+│   ├── dev_test.py        # Basic testing
+│   └── dev_castle.py      # Example: castle generation
+└── pyproject.toml         # Package configuration
+```
+
+## Available Tools
+
+For the complete and up-to-date tool list, see [USAGE.md](../docs/USAGE.md).
+
+**Categories:**
+- **System**: ping, get_document_info, get_logs, set_debug_mode
+- **Object Creation**: create_object, create_objects, create_text, create_text_dot
+- **Object Manipulation**: modify_object, delete_object, select_objects, get_object_properties, set_object_properties
+- **Boolean Operations**: boolean_operation (union, difference, intersection)
+- **Transform**: copy_object, mirror_object, array_linear, array_polar
+- **Curves**: offset_curve, fillet_curves, chamfer_curves
+- **Surfaces**: loft_curves, extrude_curve, revolve_curve
+- **Dimensions**: create_linear_dimension, create_angular_dimension, create_radial_dimension
+- **Layers & Materials**: create_layer, create_material, assign_material_to_layer
+- **Scripts**: execute_rhinoscript_python_code
+
+## Development
+
+```bash
+# Run tests
+uv run python dev/dev_test.py
+
+# Build package
+uv build
+
+# Publish to PyPI
+uv publish
+```
+
+## Documentation
+
+- [Main README](../README.md) - Installation and usage
+- [AGENTS.md](../AGENTS.md) - Agent-focused guide
+- [USAGE.md](../docs/USAGE.md) - Tool reference and usage examples

rhinoclaw-0.7.0/pyproject.toml

@@ -0,0 +1,70 @@
+[project]
+name = "rhinoclaw"
+version = "0.7.0"
+description = "Rhino integration through the Model Context Protocol"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    {name = "Solid AI", email = "info@solid-ai.ai"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "fastmcp>=2.11.2",
+    "mcp[cli]>=1.12.4",
+    "websockets>=12.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+rhinoclaw = "rhinoclaw.server:main"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+# The GH component catalog (introspected ground truth for graph authoring)
+# must ship inside the wheel — find_gh_component reads it at runtime.
+rhinoclaw = ["static/*.json"]
+
+[project.urls]
+"Homepage" = "https://github.com/McMuff86/rhinoclaw"
+"Bug Tracker" = "https://github.com/McMuff86/rhinoclaw/issues"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+# Keep ruleset conservative for now; expand (I, UP, B) once codebase settles.
+select = ["E", "F", "W"]
+ignore = [
+    "E501",  # line too long — long docstring tables are common
+    "E701",  # multiple statements on one line — used for compact param flattening
+    "W291",  # trailing whitespace — pre-existing, will sweep separately
+    "W293",  # blank line whitespace — pre-existing
+]
+
+[tool.ruff.lint.per-file-ignores]
+# __init__.py re-exports tool modules so FastMCP picks up @mcp.tool() decorators.
+# Imports look "unused" but are required side-effects.
+"src/rhinoclaw/__init__.py" = ["F401"]
+"tests/**" = ["F401", "F841"]

rhinoclaw-0.7.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rhinoclaw-0.7.0/src/rhinoclaw/__init__.py

@@ -0,0 +1,154 @@
+"""Rhino integration through the Model Context Protocol."""
+
+__version__ = "0.7.0"
+
+# Expose key classes and functions for easier imports
+from .prompts.assert_general_strategy import asset_general_strategy
+from .server import RhinoConnection, get_rhino_connection, logger, mcp
+from .static.rhinoscriptsyntax import rhinoscriptsyntax_json
+from .tools.array_linear import array_linear
+from .tools.array_polar import array_polar
+from .tools.assign_material_to_layer import assign_material_to_layer
+from .tools.batch_operations import batch_operations
+from .tools.boolean_operation import boolean_operation
+from .tools.build_and_bake_gh import build_and_bake_gh
+from .tools.build_and_bake_recipe import build_and_bake_recipe
+from .tools.build_gh_definition import build_gh_definition
+from .tools.build_gh_interactive import build_gh_interactive
+from .tools.chamfer_curves import chamfer_curves
+from .tools.check_setup import rhinoclaw_doctor
+from .tools.copy_object import copy_object
+from .tools.create_angular_dimension import create_angular_dimension
+from .tools.create_layer import create_layer
+from .tools.create_leader import create_leader
+from .tools.create_linear_dimension import create_linear_dimension
+from .tools.create_material import create_material
+from .tools.create_object import create_object
+from .tools.create_objects import create_objects
+from .tools.create_radial_dimension import create_radial_dimension
+from .tools.create_text import create_text
+from .tools.create_text_dot import create_text_dot
+from .tools.delete_layer import delete_layer
+from .tools.delete_object import delete_object
+from .tools.deploy_gh_to_compute import deploy_gh_to_compute
+from .tools.erp_bridge import erp_invoke, erp_list_tools
+from .tools.execute_python3_code import execute_python3_code, get_script_capabilities
+from .tools.execute_rhinoscript_python_code import execute_rhinoscript_python_code
+from .tools.export_file import export_file
+from .tools.export_mesh import export_mesh
+from .tools.extrude_curve import extrude_curve
+from .tools.fillet_curves import fillet_curves
+from .tools.find_gh_component import find_gh_component
+from .tools.find_nearby import find_nearby
+from .tools.find_objects import find_objects
+from .tools.get_auth_status import get_auth_status
+from .tools.get_command_history import get_command_history
+from .tools.hello import hello
+from .tools.get_document_info import get_document_info
+from .tools.judge_door_placement import judge_door_placement
+from .tools.get_logs import clear_logs, get_logs
+from .tools.get_object_info import get_object_info
+from .tools.get_objects_info import get_objects_info
+from .tools.get_relationships import get_relationships
+
+# Object Properties
+from .tools.get_object_properties import get_object_properties
+from .tools.get_or_set_current_layer import get_or_set_current_layer
+from .tools.get_rhinoscript_python_code_guide import get_rhinoscript_python_code_guide
+from .tools.get_rhinoscript_python_function_names import (
+    get_rhinoscript_python_function_names,
+)
+from .tools.get_selected_objects_info import get_selected_objects_info
+from .tools.get_session_stats import get_session_stats, new_session, set_logging_enabled
+from .tools.get_ui_state import get_ui_state, wait_until_ready
+from .tools.import_mesh import import_mesh
+from .tools.loft_curves import loft_curves
+from .tools.log_thought import log_thought
+from .tools.mesh_from_brep import mesh_from_brep
+from .tools.mirror_object import mirror_object
+from .tools.modify_object import modify_object
+from .tools.modify_objects import modify_objects
+from .tools.offset_curve import offset_curve
+
+# File Operations
+from .tools.open_file import open_file
+from .tools.ping import ping
+from .tools.place_doors import place_doors
+from .tools.preflight import preflight
+from .tools.recall_placements import recall_placements
+from .tools.redo import redo
+from .tools.revolve_curve import revolve_curve
+from .tools.run_native_command import run_native_command
+from .tools.save_file import save_file
+from .tools.select_objects import select_objects
+from .tools.set_debug_mode import set_debug_mode, set_debug_mode_tool
+from .tools.set_object_properties import set_object_properties
+from .tools.set_render_settings import set_render_settings
+from .tools.set_view import set_view
+from .tools.set_camera import set_camera
+from .tools.orbit_camera import orbit_camera
+from .tools.zoom_extents import zoom_extents
+from .tools.zoom_selected import zoom_selected
+from .tools.capture_viewport import capture_viewport
+from .tools.render_view import render_view
+from .tools.add_light import add_light
+from .tools.create_block import create_block
+from .tools.create_group import create_group
+from .tools.explode_block import explode_block
+from .tools.insert_block import insert_block
+from .tools.is_inside import is_inside
+from .tools.list_capabilities import list_capabilities
+from .tools.scene_summary import scene_summary
+from .tools.subscribe_events import subscribe_events
+from .tools.undo import undo
+from .tools.ungroup import ungroup
+from .tools.validate_gh_definition import validate_gh_definition
+from .tools.wait_for_object_event import wait_for_object_event
+
+# Grasshopper Operations
+from .tools.bake_grasshopper import bake_grasshopper
+from .tools.get_grasshopper_outputs import get_grasshopper_outputs
+from .tools.inspect_grasshopper_definition import inspect_grasshopper_definition
+from .tools.list_grasshopper_definitions import list_grasshopper_definitions
+from .tools.load_grasshopper_definition import load_grasshopper_definition
+from .tools.run_grasshopper import run_grasshopper
+from .tools.set_grasshopper_parameter import set_grasshopper_parameter
+from .tools.solve_grasshopper import solve_grasshopper
+from .tools.unload_grasshopper_definition import unload_grasshopper_definition
+from .tools.grasshopper_interactive import (
+    run_door_script,
+    run_grasshopper_interactive,
+)
+
+# VisualARQ BIM (graceful degradation without the plugin)
+from .tools.visualarq import (
+    va_add_level,
+    va_create_door,
+    va_create_wall,
+    va_ifc_export,
+    va_ifc_import,
+    va_list_levels,
+    va_list_styles,
+    va_status,
+)
+
+# WebSocket Streaming (Real-Time Events)
+from .tools.stream_commands import (
+    cancel_rhino_command,
+    clear_stream_buffer,
+    connect_rhino_stream,
+    disconnect_rhino_stream,
+    get_stream_events,
+    get_stream_status,
+    run_script_async,
+    send_rhino_input,
+    wait_for_prompt,
+)
+
+# WebSocket Client
+from .websocket_client import (
+    RhinoWebSocketClient,
+    WebSocketEvent,
+    get_websocket_client,
+    reset_websocket_client,
+)

rhinoclaw-0.7.0/src/rhinoclaw/config.py

@@ -0,0 +1,134 @@
+"""
+Runtime configuration for the RhinoClaw MCP server.
+
+All values can be overridden via environment variables prefixed with
+``RHINOCLAW_``. Stored as a frozen dataclass so the same instance can be
+shared between threads without surprises.
+
+Examples
+--------
+::
+
+    RHINOCLAW_HOST=192.168.1.20 RHINOCLAW_PORT=1999 uvx rhinoclaw
+
+::
+
+    RHINOCLAW_AUTH_TOKEN=$(openssl rand -hex 16) uvx rhinoclaw
+
+The defaults match the historical behaviour (loopback, port 1999, 15s
+timeout, no auth) so existing setups keep working when the variables
+are unset.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+_TRUE_VALUES = {"1", "true", "yes", "on"}
+
+
+def _env_str(name: str, default: str) -> str:
+    return os.environ.get(name, default)
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return int(raw)
+    except ValueError:
+        return default
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in _TRUE_VALUES
+
+
+def _default_log_dir() -> Path:
+    """Pick a sane per-OS log directory, fall back to a project-local one."""
+    explicit = os.environ.get("RHINOCLAW_LOG_DIR")
+    if explicit:
+        return Path(explicit).expanduser()
+
+    if os.name == "nt":
+        base = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA")
+        if base:
+            return Path(base) / "rhinoclaw" / "logs"
+    else:
+        xdg = os.environ.get("XDG_STATE_HOME")
+        if xdg:
+            return Path(xdg) / "rhinoclaw" / "logs"
+        home = os.environ.get("HOME")
+        if home:
+            return Path(home) / ".local" / "state" / "rhinoclaw" / "logs"
+
+    # Last-resort fallback: project-local (legacy behaviour).
+    return Path(__file__).resolve().parent.parent.parent / "logs"
+
+
+@dataclass(frozen=True)
+class Settings:
+    """Runtime configuration. Access via :func:`get_settings`."""
+
+    host: str
+    port: int
+    ws_port: int
+    timeout_seconds: float
+    max_timeout_seconds: float
+    debug: bool
+    auth_token: Optional[str]
+    log_format: str  # "text" or "json"
+    log_dir: Path
+
+    @property
+    def auth_required(self) -> bool:
+        return bool(self.auth_token)
+
+    @classmethod
+    def from_env(cls) -> "Settings":
+        return cls(
+            host=_env_str("RHINOCLAW_HOST", "127.0.0.1"),
+            port=_env_int("RHINOCLAW_PORT", 1999),
+            ws_port=_env_int("RHINOCLAW_WS_PORT", 2000),
+            timeout_seconds=_env_float("RHINOCLAW_TIMEOUT", 15.0),
+            max_timeout_seconds=_env_float("RHINOCLAW_MAX_TIMEOUT", 120.0),
+            debug=_env_bool("RHINOCLAW_DEBUG", False),
+            auth_token=os.environ.get("RHINOCLAW_AUTH_TOKEN") or None,
+            log_format=_env_str("RHINOCLAW_LOG_FORMAT", "text").lower(),
+            log_dir=_default_log_dir(),
+        )
+
+
+_cached: Optional[Settings] = None
+
+
+def get_settings() -> Settings:
+    """Return the process-wide settings, loading from env on first call."""
+    global _cached
+    if _cached is None:
+        _cached = Settings.from_env()
+    return _cached
+
+
+def reload_settings() -> Settings:
+    """Force re-read from environment. Useful for tests."""
+    global _cached
+    _cached = Settings.from_env()
+    return _cached

rhinoclaw-0.7.0/src/rhinoclaw/logging_setup.py

@@ -0,0 +1,101 @@
+"""
+Logging configuration for RhinoClaw.
+
+Two formats are supported:
+
+* ``text`` (default) — human-readable, single-line, includes the
+  request_id when one is attached via ``logger.<level>(msg, extra={...})``.
+* ``json``           — newline-delimited JSON for log shippers.
+
+Switch via ``RHINOCLAW_LOG_FORMAT=json``. Once a process has called
+:func:`configure_logging` the root logger is set up; subsequent calls
+re-apply the format and level (handy for tests).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rhinoclaw.config import Settings
+
+
+# Fields that the stdlib LogRecord always carries; everything else on the
+# record dict is treated as user-supplied "extra" metadata and merged into
+# the structured payload.
+_STD_RECORD_FIELDS = frozenset({
+    "name", "msg", "args", "levelname", "levelno", "pathname", "filename",
+    "module", "exc_info", "exc_text", "stack_info", "lineno", "funcName",
+    "created", "msecs", "relativeCreated", "thread", "threadName",
+    "processName", "process", "message", "asctime", "taskName",
+})
+
+
+class _JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, object] = {
+            "ts": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(timespec="milliseconds"),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+
+        for key, value in record.__dict__.items():
+            if key in _STD_RECORD_FIELDS or key.startswith("_"):
+                continue
+            try:
+                json.dumps(value)
+                payload[key] = value
+            except (TypeError, ValueError):
+                payload[key] = repr(value)
+
+        if record.exc_info:
+            payload["exception"] = self.formatException(record.exc_info)
+
+        return json.dumps(payload, ensure_ascii=False)
+
+
+class _TextFormatter(logging.Formatter):
+    """Human-readable formatter that surfaces the request_id when present."""
+
+    _BASE_FMT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    def __init__(self) -> None:
+        super().__init__(self._BASE_FMT)
+
+    def format(self, record: logging.LogRecord) -> str:
+        base = super().format(record)
+        request_id = getattr(record, "request_id", None)
+        if request_id:
+            return f"{base} [req={request_id}]"
+        return base
+
+
+def _build_handler(log_format: str) -> logging.Handler:
+    handler = logging.StreamHandler(sys.stderr)
+    if log_format == "json":
+        handler.setFormatter(_JsonFormatter())
+    else:
+        handler.setFormatter(_TextFormatter())
+    return handler
+
+
+def configure_logging(settings: "Settings") -> None:
+    """Configure the root logger according to ``settings``.
+
+    Idempotent — handlers installed by previous calls are removed.
+    """
+    root = logging.getLogger()
+    for existing in list(root.handlers):
+        # Only remove handlers we installed, identified by a marker attribute.
+        if getattr(existing, "_rhinoclaw_handler", False):
+            root.removeHandler(existing)
+
+    handler = _build_handler(settings.log_format)
+    handler._rhinoclaw_handler = True  # type: ignore[attr-defined]
+    root.addHandler(handler)
+    root.setLevel(logging.DEBUG if settings.debug else logging.INFO)

rhinoclaw-0.7.0/src/rhinoclaw/prompts/assert_general_strategy.py

@@ -0,0 +1,25 @@
+from rhinoclaw.server import mcp
+
+
+@mcp.prompt()
+def asset_general_strategy() -> str:
+    """Defines the preferred strategy for creating assets in Rhino"""
+    return """
+    
+    QUERY STRATEGY:
+    - if the id of the object is known, use the id to query the object.
+    - if the id is not known, use the name of the object to query the object.
+
+
+    CREATION STRATEGY:
+
+    0. Before anything, always check the document from get_document_info().
+    1. If the execute_rhinoscript_python_code() function is not able to create the objects, use the create_objects() function.
+    2. If there are multiple objects, use the method create_objects() to create multiple objects at once. Do not attempt to create them one by one if they are more than 10.
+    3. When including an object into document, ALWAYS make sure that the name of the object is meanful.
+    4. Try to include as many objects as possible accurately and efficiently. If the command is not able to include so many data, try to create the objects in batches.
+
+    When creating rhinoscript python code:
+    - do not hallucinate, only use the syntax that is supported by rhinoscriptsyntax or Rhino.Geometry.
+    - double check the code if any of the code is not correct, and fix it.
+    """