robotcode-repl-server 0.100.2__tar.gz → 0.101.0__tar.gz

{robotcode_repl_server-0.100.2 → robotcode_repl_server-0.101.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-repl-server
-Version: 0.100.2
+Version: 0.101.0
 Summary: RobotCode REPL Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -24,8 +24,8 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-jsonrpc2==0.100.2
-Requires-Dist: robotcode-runner==0.100.2
+Requires-Dist: robotcode-jsonrpc2==0.101.0
+Requires-Dist: robotcode-runner==0.101.0
 Description-Content-Type: text/markdown
 
 # robotcode-repl-server

{robotcode_repl_server-0.100.2 → robotcode_repl_server-0.101.0}/pyproject.toml

@@ -27,8 +27,8 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-  "robotcode-jsonrpc2==0.100.2",
-  "robotcode-runner==0.100.2"
+  "robotcode-jsonrpc2==0.101.0",
+  "robotcode-runner==0.101.0"
 ]
 
 [project.entry-points.robotcode]

robotcode_repl_server-0.101.0/src/robotcode/repl_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.101.0"

{robotcode_repl_server-0.100.2 → robotcode_repl_server-0.101.0}/src/robotcode/repl_server/interpreter.py

@@ -1,16 +1,17 @@
+import textwrap
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from threading import Event
 from typing import TYPE_CHECKING, Iterator, List, Optional, Protocol, Union, runtime_checkable
-from uuid import uuid4
 
 from robot.running import Keyword
+from robot.utils.markuputils import html_format
+from robot.utils.robottime import elapsed_time_to_string
 
 from robotcode.core.utils.dataclasses import as_json
 from robotcode.repl.base_interpreter import BaseInterpreter, is_true
-
-from .html_writer import Element, create_keyword_html, create_message_html
+from robotcode.robot.utils import get_robot_version
 
 if TYPE_CHECKING:
     from robot import result, running
@@ -76,13 +77,28 @@ class KeywordResultData(ResultData):
     message: str
     start_time: Optional[str]
     end_time: Optional[str]
-    elapsed_time: Optional[float]
+    elapsed_time: Optional[str]
 
     items: List[ResultData] = field(default_factory=list)
 
     node_type: str = "keyword"
 
 
+if get_robot_version() < (7, 0):
+
+    def make_elapsed_time_str(elapsed_time: Union[timedelta, int, float, None]) -> Optional[str]:
+        if elapsed_time is None:
+            return None
+        return str(elapsed_time_to_string(elapsed_time))
+
+else:
+
+    def make_elapsed_time_str(elapsed_time: Union[timedelta, int, float, None]) -> Optional[str]:
+        if elapsed_time is None:
+            return None
+        return str(elapsed_time_to_string(elapsed_time, seconds=True))
+
+
 class Interpreter(BaseInterpreter):
     def __init__(
         self,
@@ -93,45 +109,24 @@ class Interpreter(BaseInterpreter):
         self.has_input = Event()
         self.executed = Event()
         self._code: List[str] = []
-        self._html_result: Optional[Element] = None
-        self._result_stack: List[Element] = []
-        self._output_stack: List[Element] = []
-        self._shadow_marker: Optional[str] = None
         self._success: Optional[bool] = None
         self._result_data: Optional[ResultData] = None
         self._result_data_stack: List[ResultData] = []
         self.collect_messages: bool = False
         self._has_shutdown = False
+        self._cell_errors: List[str] = []
 
     def shutdown(self) -> None:
         self._code = []
         self._has_shutdown = True
         self.has_input.set()
-        # self.executed.set()
 
     def execute(self, source: str) -> ExecutionResult:
-        self._result_stack = []
         self._result_data_stack = []
 
         self._success = None
         try:
-            self._shadow_marker = str(uuid4())
-
-            html_result = Element("div", classes=["robot-results"])
-
-            with html_result.tag(
-                "div", attributes={"data-shadow-marker": self._shadow_marker}, styles={"display": "none"}
-            ):
-                pass
-
-            outer_test: Optional[Element] = None
-            with html_result.tag("div", classes=["result_body"]) as body:
-                with body.tag("div", classes=["test"]) as test:
-                    with test.tag("div", classes=["children"], styles={"display": "block"}):
-                        pass
-                    outer_test = test
-
-            self._html_result = outer_test
+            self._cell_errors = []
             self._result_data = RootResultData()
 
             self.executed.clear()
@@ -148,12 +143,18 @@ class Interpreter(BaseInterpreter):
                         ExecutionOutput(
                             "x-application/robotframework-repl-log", as_json(self._result_data, compact=True)
                         ),
-                        ExecutionOutput(
-                            "x-application/robotframework-repl-html", html_result.as_str(only_children=True)
+                        *(
+                            [ExecutionOutput("application/vnd.code.notebook.stderr", "\n".join(self._cell_errors))]
+                            if self._cell_errors
+                            else []
                         ),
                     ]
                     if self._success is not None
-                    else []
+                    else (
+                        [ExecutionOutput("application/vnd.code.notebook.stderr", "\n".join(self._cell_errors))]
+                        if self._cell_errors
+                        else []
+                    )
                 ),
             )
         except BaseException as e:
@@ -164,7 +165,12 @@ class Interpreter(BaseInterpreter):
             s = self._code.pop(0)
             test, errors = self.get_test_body_from_string(s)
             if errors:
-                raise CellInputError(errors)
+                self._cell_errors.append(
+                    "CellInputError: " + ("\n" + textwrap.indent("\n".join(errors), "    "))
+                    if len(errors) > 1
+                    else errors[0]
+                )
+                # raise CellInputError(errors)
 
             for kw in test.body:
                 yield kw
@@ -183,29 +189,6 @@ class Interpreter(BaseInterpreter):
                 )
             )
 
-        if level in ("DEBUG", "TRACE"):
-            return
-
-        if self._html_result is None:
-            return
-
-        items = next(
-            (
-                i
-                for i in self._html_result.children
-                if isinstance(i, Element) and i.tag_name == "div" and i.classes is not None and "children" in i.classes
-            ),
-            None,
-        )
-        if items is None:
-            items = Element("div", classes=["children"])
-            self._html_result.add_element(items)
-
-        id = f"message-{len(items.children)}"
-
-        message_data = create_message_html(id, message, level, html, timestamp, shadow_root_id=self._shadow_marker)
-        items.add_element(message_data)
-
     def message(
         self, message: str, level: str, html: Union[str, bool] = False, timestamp: Union[datetime, str, None] = None
     ) -> None:
@@ -232,7 +215,7 @@ class Interpreter(BaseInterpreter):
                 name=result.name if getattr(result, "name", None) else "",
                 owner=result.owner if getattr(result, "owner", None) else "",
                 source_name=result.source_name if getattr(result, "source_name", None) else "",
-                doc=result.doc if getattr(result, "doc", None) else "",
+                doc=html_format(result.doc) if getattr(result, "doc", None) else "",
                 args=list(result.args) if getattr(result, "args", None) else [],
                 assign=list(result.assign) if getattr(result, "assign", None) else [],
                 tags=list(result.tags) if getattr(result, "tags", None) else [],
@@ -242,43 +225,29 @@ class Interpreter(BaseInterpreter):
                 message=result.message,
                 start_time=result.starttime,
                 end_time=result.endtime,
-                elapsed_time=result.elapsedtime,
+                elapsed_time=(
+                    make_elapsed_time_str(result.elapsedtime)
+                    if get_robot_version() < (7, 0)
+                    else make_elapsed_time_str(result.elapsed_time)
+                ),
             )
             if self._result_data is not None and isinstance(self._result_data, ResultDataWithChildren):
                 self._result_data.items.append(kw_data)
             self._result_data_stack.append(self._result_data)
             self._result_data = kw_data
 
-        if self._html_result is not None:
-            self._result_stack.append(self._html_result)
-            kw = self.create_keyword_html_element(result)
-
-            children = next(
-                (
-                    i
-                    for i in self._html_result.children
-                    if isinstance(i, Element)
-                    and i.tag_name == "div"
-                    and i.classes is not None
-                    and "children" in i.classes
-                ),
-                None,
-            )
-
-            if children is None:
-                self._html_result.add_element(kw)
-            else:
-                children.add_element(kw)
-
-            self._html_result = kw
-
     def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
         if data.type in ["IF/ELSE ROOT", "TRY/EXCEPT ROOT"]:
             return
+
         if self._result_data is not None:
             if isinstance(self._result_data, KeywordResultData):
                 self._result_data.end_time = result.endtime
-                self._result_data.elapsed_time = result.elapsedtime
+                self._result_data.elapsed_time = (
+                    make_elapsed_time_str(result.elapsedtime)
+                    if get_robot_version() < (7, 0)
+                    else make_elapsed_time_str(result.elapsed_time)
+                )
                 self._result_data.status = result.status
                 self._result_data.message = result.message
 
@@ -289,69 +258,6 @@ class Interpreter(BaseInterpreter):
         elif result.status == "PASS" and self.last_result is not False:
             self._success = True
 
-        if self._html_result is not None and isinstance(self._html_result, Element):
-            kw = self.create_keyword_html_element(result)
-
-            old_children = next(
-                (
-                    i
-                    for i in self._html_result.children
-                    if isinstance(i, Element)
-                    and i.tag_name == "div"
-                    and i.classes is not None
-                    and "children" in i.classes
-                ),
-                None,
-            )
-            if old_children is not None:
-                new_children = next(
-                    (
-                        i
-                        for i in kw.children
-                        if isinstance(i, Element)
-                        and i.tag_name == "div"
-                        and i.classes is not None
-                        and "children" in i.classes
-                    ),
-                    None,
-                )
-                if new_children is None:
-                    new_children = Element("div", classes=["children"])
-                    self._html_result.add_element(new_children)
-
-                for old_child in old_children.children:
-                    if not (
-                        isinstance(old_child, Element)
-                        and old_child.tag_name == "table"
-                        and old_child.classes is not None
-                        and "metadata" in old_child.classes
-                    ):
-                        new_children.add_element(old_child)
-
-            self._html_result.children = kw.children
-
-        self._html_result = self._result_stack.pop()
-
-    def create_keyword_html_element(self, result: "result.Keyword") -> Element:
-        return create_keyword_html(
-            id=result.id,
-            name=result.name if getattr(result, "name", None) else None,
-            owner=result.owner if getattr(result, "owner", None) else None,
-            source_name=result.source_name if getattr(result, "source_name", None) else None,
-            doc=result.doc if getattr(result, "doc", None) else None,
-            args=result.args if getattr(result, "args", None) else (),
-            assign=result.assign if getattr(result, "assign", None) else (),
-            tags=result.tags if getattr(result, "tags", None) else (),
-            timeout=result.timeout if getattr(result, "timeout", None) else None,
-            type=result.type,
-            status=result.status,
-            message=result.message,
-            start_time=result.starttime,
-            end_time=result.endtime,
-            elapsed_time=result.elapsedtime,
-            shadow_root_id=self._shadow_marker,
-        )
-
     def run_input(self) -> None:
         self.has_input.wait()
         if self._has_shutdown:

robotcode_repl_server-0.100.2/src/robotcode/repl_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.100.2"

robotcode_repl_server-0.100.2/src/robotcode/repl_server/html_writer.py

@@ -1,324 +0,0 @@
-from contextlib import contextmanager
-from datetime import datetime, timedelta
-from typing import Any, Dict, Generator, List, Optional, Sequence, TypeVar, Union
-
-from robot.utils.robottime import elapsed_time_to_string
-
-from robotcode.repl.base_interpreter import is_true
-from robotcode.robot.utils import get_robot_version
-
-
-class ElementDataBase:
-    def as_str(self, indent: int = 0) -> str:
-        raise NotImplementedError
-
-    def __str__(self) -> str:
-        return self.as_str(0)
-
-
-_T = TypeVar("_T", bound=ElementDataBase)
-
-
-class TextElement(ElementDataBase):
-    def __init__(self, text: str) -> None:
-        self.text = text
-
-    def as_str(self, indent: int = 0) -> str:
-        return f"{'  '*indent}{self.text}"
-
-
-class RawElement(ElementDataBase):
-    def __init__(self, text: str) -> None:
-        self.text = text
-
-    def as_str(self, indent: int = 0) -> str:
-        return f"{'  '*indent}{self.text}"
-
-
-class Element(ElementDataBase):
-    def __init__(
-        self,
-        tag_name: str,
-        text: Optional[str] = None,
-        classes: Optional[List[str]] = None,
-        styles: Optional[Dict[str, str]] = None,
-        attributes: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> None:
-        self.tag_name = tag_name
-        self.classes = classes
-        self.styles = styles
-        if attributes is None:
-            attributes = {}
-        attributes.update(kwargs)
-        self.attributes = attributes
-        self.children: List[ElementDataBase] = []
-
-        if text is not None:
-            self.add_element(TextElement(text))
-
-    def add_element(self, child: _T) -> _T:
-        self.children.append(child)
-        return child
-
-    @contextmanager
-    def tag(
-        self,
-        tag_name: str,
-        *,
-        text: Optional[str] = None,
-        classes: Optional[List[str]] = None,
-        styles: Optional[Dict[str, str]] = None,
-        attributes: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> Generator["Element", None, None]:
-        element = Element(tag_name, text=text, classes=classes, styles=styles, attributes=attributes, **kwargs)
-
-        yield element
-
-        self.add_element(element)
-
-    def add_raw(self, text: Any) -> None:
-        self.add_element(RawElement(str(text)))
-
-    def add_text(self, text: Any) -> None:
-        self.add_element(TextElement(str(text)))
-
-    def _build_attributes(self) -> str:
-        result = []
-        if self.classes:
-            result.append(f'class="{" ".join(s for s in self.classes if s)}"')
-        if self.styles:
-            result.append(f'style="{"; ".join(f"{k}: {v}" for k, v in self.styles.items() if v)}"')
-        if self.attributes:
-            result.extend(f'{k}="{v}"' for k, v in self.attributes.items())
-
-        return " ".join(result)
-
-    NON_BREAKABLE_TAGS = {"span", "a", "b", "i", "u", "strong", "em", "code", "pre", "tt", "samp", "kbd", "var", "td"}
-
-    def as_str(self, indent: int = 0, *, only_children: bool = False) -> str:
-        if not only_children:
-            attributes = self._build_attributes()
-
-            if attributes:
-                start_tag = f"<{self.tag_name} {attributes}>"
-            else:
-                start_tag = f"<{self.tag_name}>"
-
-            end_tag = f"</{self.tag_name}>"
-
-            result = "  " * indent + start_tag
-        else:
-            result = ""
-            end_tag = None
-
-        if self.children:
-            result += "\n" if self.tag_name not in self.NON_BREAKABLE_TAGS else ""
-            for child in self.children:
-                result += child.as_str((indent + 1) if self.tag_name not in self.NON_BREAKABLE_TAGS else 0) + (
-                    "\n" if self.tag_name not in self.NON_BREAKABLE_TAGS else ""
-                )
-            result += ("  " * indent) if self.tag_name not in self.NON_BREAKABLE_TAGS else ""
-
-        if end_tag:
-            result += end_tag
-
-        return result
-
-
-def create_keyword_html(
-    id: Optional[str] = None,
-    name: Optional[str] = "",
-    owner: Optional[str] = None,
-    source_name: Optional[str] = None,
-    doc: Optional[str] = "",
-    args: Sequence[str] = (),
-    assign: Sequence[str] = (),
-    tags: Sequence[str] = (),
-    timeout: Optional[str] = None,
-    type: str = "KEYWORD",
-    status: str = "FAIL",
-    message: str = "",
-    start_time: Union[datetime, str, None] = None,
-    end_time: Union[datetime, str, None] = None,
-    elapsed_time: Union[timedelta, int, float, None] = None,
-    shadow_root_id: Optional[str] = None,
-) -> Element:
-    result = Element("div", classes=["keyword"], id=id)
-
-    elapsed_time_str = (
-        (
-            elapsed_time_to_string(elapsed_time)
-            if get_robot_version() < (7, 0)
-            else elapsed_time_to_string(elapsed_time, seconds=True)
-        )
-        if elapsed_time is not None
-        else ""
-    )
-
-    with result.tag(
-        "div",
-        classes=["element-header", "closed" if status not in ["FAIL"] else ""],
-        onclick=f"toggleKeyword('{id}', '{shadow_root_id}')",
-    ) as e_element_header:
-        with e_element_header.tag(
-            "div",
-            classes=["element-header-left"],
-            title=f"{type.upper()} {owner}.{name} [{status}]",
-        ) as e_header_left:
-            if elapsed_time is not None:
-                with e_header_left.tag("span", classes=["elapsed"]) as e_elapsed:
-                    e_elapsed.add_text(elapsed_time_str)
-            with e_header_left.tag("span", classes=["label", status.lower()]) as e_label:
-                e_label.add_text(str(type).upper())
-            with e_header_left.tag("span", classes=["assign"]) as e_assign:
-                e_assign.add_text("    ".join(assign))
-            with e_header_left.tag("span", classes=["name"]) as e_name:
-                with e_name.tag("span", classes=["parent-name"]) as parent_name:
-                    parent_name.add_text((owner + " . ") if owner else "")
-                e_name.add_text(name)
-            e_header_left.add_raw("&nbsp;")
-            with e_header_left.tag("span", classes=["arg"]) as args_tag:
-                args_tag.add_text("    ".join(args))
-        with e_element_header.tag("div", classes=["element-header-right"]) as e_header_right:
-            with e_header_right.tag(
-                "div",
-                classes=["expand"],
-                title="Expand all",
-                onclick=f"expandAll(event, '{id}', '{shadow_root_id}')",
-            ):
-                pass
-            with e_header_right.tag(
-                "div",
-                classes=["collapse"],
-                title="Collapse all",
-                onclick=f"collapseAll(event, '{id}', '{shadow_root_id}')",
-            ):
-                pass
-            with e_header_right.tag(
-                "div",
-                classes=["link"],
-                title="Highlight this item",
-                onclick=f"makeElementVisible(event, '{id}', '{shadow_root_id}')",
-            ):
-                pass
-        with e_element_header.tag("div", classes=["element-header-toggle"], title="Toggle visibility"):
-            pass
-
-    with result.tag(
-        "div", classes=["children", "populated"], styles={"display": "none" if status not in ["FAIL"] else "block"}
-    ) as e_children:
-        with e_children.tag("table", classes=["metadata", "keyword-metadata"]) as e_body:
-            if doc:
-                with e_body.tag("tr") as tr:
-                    with tr.tag("th", text="Documentation:"):
-                        pass
-                    with tr.tag("td", classes=["doc"]) as td:
-                        td.add_text(doc)
-            if tags:
-                with e_body.tag("tr") as tr:
-                    with tr.tag("th", text="Tags:"):
-                        pass
-                    with tr.tag("td", classes=["tags"]) as td:
-                        td.add_text(", ".join(tags))
-            if timeout:
-                with e_body.tag("tr") as tr:
-                    with tr.tag("th", text="Timeout:"):
-                        pass
-                    with tr.tag("td", classes=["timeout"]) as td:
-                        td.add_text(timeout)
-            if source_name:
-                with e_body.tag("tr") as tr:
-                    with tr.tag("th", text="Source:"):
-                        pass
-                    with tr.tag("td", classes=["source"]) as td:
-                        td.add_text(source_name)
-            with e_body.tag("tr") as tr:
-                with tr.tag("th", text="Start / End / Elapsed:"):
-                    pass
-                with tr.tag("td", classes=["message"]) as td:
-                    td.add_text(str(start_time) + " / " + str(end_time) + " / " + elapsed_time_str)
-            if message:
-                with e_body.tag("tr") as tr:
-                    with tr.tag("th", text="Message:"):
-                        pass
-                    with tr.tag("td", classes=["message"]) as td:
-                        td.add_text(message)
-
-    return result
-
-
-def create_message_html(
-    id: str,
-    message: str,
-    level: str,
-    html: Union[str, bool] = False,
-    timestamp: Union[datetime, str, None] = None,
-    shadow_root_id: Optional[str] = None,
-) -> Element:
-    result = Element("table", classes=["messages", f"{level.lower()}-message"], id=id)
-
-    with result.tag("tr", classes=["message-row"]) as tr:
-        with tr.tag("td", classes=["time"]) as td:
-            if isinstance(timestamp, datetime):
-                td.add_text(timestamp.strftime("%H:%M:%S"))
-            else:
-                td.add_text(timestamp)
-        with tr.tag("td", classes=["level", level.lower()]) as td:
-            with td.tag("span", classes=["label", level.lower()]) as sp:
-                sp.add_text(level.upper())
-        with tr.tag("td", classes=["message"]) as td:
-            if is_true(html):
-                td.add_raw(message)
-            else:
-                td.add_text(message)
-        with tr.tag(
-            "td",
-            classes=["select-message"],
-            onclick=f"selectMessage('{id}', '{shadow_root_id}')",
-            title="Select message text",
-        ) as td:
-            with td.tag("div"):
-                pass
-
-    return result
-
-
-if __name__ == "__main__":
-    # div = Element("div", id="main", classes=["test", "test2"], styles={"color": "red", "font-size": "12px"})
-    # p = div.add_element(Element("p", text="Hello, world!"))
-    # p.add_element(Element("span", text="This is a test"))
-    # print(div)
-
-    # body = Element("body")
-    # with body.tag("div", id="main", classes=["test", "test2"], styles={"color": "red"}) as div:
-    #     with div.tag("p") as p:
-    #         p.add_text("Hello, world!")
-    #         with p.tag("span") as span:
-    #             span.add_text("This is a test")
-    #             with span.tag("br"):
-    #                 pass
-    #             span.add_text("This is a test")
-    #             with span.tag("br", id="test"):
-    #                 pass
-    # print(body)
-
-    # r = create_keyword_html(
-    #     id="ts-1-2-3-4-5-6",
-    #     name="Test Keyword",
-    #     owner="Test Library",
-    #     doc="This is a test keyword",
-    #     args=("arg1", "arg2"),
-    #     assign=("${var1}", "${var2}"),
-    #     tags=("tag1", "tag2"),
-    #     timeout="10s",
-    #     type="KEYWORD",
-    #     status="PASS",
-    #     message="This is a test message",
-    #     start_time=datetime.now(timezone.utc),
-    #     end_time=datetime.now(timezone.utc),
-    #     elapsed_time=timedelta(seconds=5),
-    # )
-    r = create_message_html("ts-1-2-3-4-5-6", "This is a test message", "INFO", timestamp="2021-10-10 12:00:00")
-    print(r)