runcell 0.1.16a0__py3-none-any.whl → 0.1.16a1__py3-none-any.whl

d5m_ai/search_replace_handler.py

@@ -0,0 +1,404 @@
+import json
+import os
+import re
+import subprocess
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from jupyter_server.base.handlers import APIHandler
+import tornado.web
+
+from .tools.grep import execute_grep_tool
+from .tools.edit import edit_file_text
+
+
+DEFAULT_MATCH_LIMIT = 200
+MAX_MATCH_LIMIT = 1000
+DEFAULT_EXCLUDE_DIRS = [
+    "node_modules",
+    ".ipynb_checkpoints",
+    "jupyterlab-env",
+    "build",
+    "lib",
+    "dist",
+    "__pycache__",
+    ".git",
+]
+DEFAULT_EXCLUDE_GLOBS: List[str] = []
+
+
+def _get_root_dir(handler: APIHandler) -> str:
+    root_dir = getattr(handler.contents_manager, "root_dir", None)
+    if not root_dir:
+        root_dir = (
+            handler.settings.get("server_root_dir")
+            or handler.settings.get("root_dir")
+            or os.getcwd()
+        )
+    return os.path.abspath(root_dir)
+
+
+def _get_repo_root(root_dir: str) -> Optional[str]:
+    if os.path.isdir(os.path.join(root_dir, ".git")):
+        return root_dir
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=root_dir,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+    except Exception:
+        return None
+
+    if result.returncode != 0:
+        return None
+
+    output = (result.stdout or "").strip()
+    return output or None
+
+
+def _resolve_target_dir(root_dir: str, path_arg: str) -> str:
+    if not path_arg or path_arg in (".", "/"):
+        target_dir = root_dir
+    else:
+        cleaned = path_arg.lstrip("/").lstrip("\\")
+        target_dir = os.path.abspath(os.path.join(root_dir, cleaned))
+
+    root_dir = os.path.abspath(root_dir)
+    if os.path.commonpath([root_dir, target_dir]) != root_dir:
+        raise ValueError("Path is outside server root.")
+    return target_dir
+
+
+def _to_display_path(file_path: str, root_dir: str) -> str:
+    if not file_path:
+        return file_path
+    try:
+        rel_path = os.path.relpath(file_path, root_dir)
+    except ValueError:
+        return file_path
+    if rel_path.startswith(".."):
+        return file_path
+    return rel_path.replace(os.sep, "/")
+
+
+def _split_list_input(value: Any) -> List[str]:
+    if not value:
+        return []
+
+    if isinstance(value, str):
+        raw_items = re.split(r"[,\n]", value)
+    elif isinstance(value, Iterable):
+        raw_items = []
+        for item in value:
+            if isinstance(item, str):
+                raw_items.extend(re.split(r"[,\n]", item))
+            else:
+                raw_items.append(str(item))
+    else:
+        raw_items = [str(value)]
+
+    cleaned = []
+    for item in raw_items:
+        stripped = item.strip().strip('"').strip("'")
+        if stripped:
+            cleaned.append(stripped)
+    return cleaned
+
+
+def _extract_simple_dir(pattern: str) -> Optional[str]:
+    candidate = pattern.strip().lstrip("/").rstrip("/")
+    if not candidate:
+        return None
+    if candidate.startswith("**/") and candidate.endswith("/**"):
+        candidate = candidate[3:-3]
+    if any(char in candidate for char in ("*", "?", "[", "]", "/", "\\")):
+        return None
+    return candidate or None
+
+
+def _classify_excludes(patterns: Iterable[str]) -> Tuple[List[str], List[str]]:
+    exclude_dirs: List[str] = []
+    exclude_globs: List[str] = []
+
+    for raw in patterns:
+        pattern = raw.strip()
+        if not pattern or pattern.startswith("#"):
+            continue
+        if pattern.startswith("!"):
+            continue
+
+        pattern = pattern.lstrip("/")
+        simple_dir = _extract_simple_dir(pattern)
+        if simple_dir:
+            exclude_dirs.append(simple_dir)
+            exclude_globs.append(simple_dir)
+            continue
+
+        if pattern.endswith("/"):
+            exclude_dirs.append(pattern.rstrip("/"))
+            continue
+
+        exclude_globs.append(pattern)
+
+    def dedupe(items: List[str]) -> List[str]:
+        seen: set[str] = set()
+        output: List[str] = []
+        for item in items:
+            if item not in seen:
+                seen.add(item)
+                output.append(item)
+        return output
+
+    return dedupe(exclude_dirs), dedupe(exclude_globs)
+
+
+def _load_gitignore_patterns(root_dir: str) -> List[str]:
+    gitignore_path = os.path.join(root_dir, ".gitignore")
+    if not os.path.isfile(gitignore_path):
+        return []
+
+    try:
+        with open(gitignore_path, "r", encoding="utf-8") as handle:
+            lines = handle.readlines()
+    except Exception:
+        return []
+
+    patterns = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        patterns.append(stripped)
+    return patterns
+
+
+def _parse_bool(value: Any, default: bool) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"0", "false", "no", "off"}:
+            return False
+        if lowered in {"1", "true", "yes", "on"}:
+            return True
+    return bool(value)
+
+
+def _parse_grep_response(result: str) -> Tuple[str, List[Dict[str, Any]], bool]:
+    try:
+        data = json.loads(result)
+    except json.JSONDecodeError:
+        return "Failed to parse search response.", [], False
+
+    if data.get("result_type") == "error":
+        return data.get("summary") or "Search failed.", [], False
+
+    matches = data.get("matches") or []
+    return data.get("summary") or "", matches, bool(data.get("truncated"))
+
+
+def _parse_files_response(result: str) -> Tuple[str, List[str]]:
+    try:
+        data = json.loads(result)
+    except json.JSONDecodeError:
+        return "Failed to parse search response.", []
+
+    if data.get("result_type") == "error":
+        return data.get("summary") or "Search failed.", []
+
+    files = data.get("files") or []
+    return data.get("summary") or "", files
+
+
+def _parse_replace_count(message: str) -> int:
+    match = re.search(r"replaced (\d+) occurrence", message or "")
+    if not match:
+        return 0
+    try:
+        return int(match.group(1))
+    except ValueError:
+        return 0
+
+
+class SearchReplaceHandler(APIHandler):
+    @tornado.web.authenticated
+    async def post(self):
+        payload = self.get_json_body() or {}
+        action = (payload.get("action") or "search").strip().lower()
+        query = (payload.get("query") or "").strip()
+        regex_enabled = bool(payload.get("regex"))
+        case_sensitive = bool(payload.get("caseSensitive", True))
+        replace_text = payload.get("replace")
+        path_arg = (payload.get("path") or "").strip()
+        use_default_excludes = _parse_bool(payload.get("useDefaultExcludes"), True)
+        user_excludes = _split_list_input(payload.get("exclude"))
+        include_patterns = _split_list_input(payload.get("include"))
+
+        if not query:
+            self.set_status(400)
+            self.finish(json.dumps({
+                "success": False,
+                "error": "Search query is required."
+            }))
+            return
+
+        root_dir = _get_root_dir(self)
+        try:
+            target_dir = _resolve_target_dir(root_dir, path_arg)
+        except ValueError:
+            self.set_status(400)
+            self.finish(json.dumps({
+                "success": False,
+                "error": "Invalid path. Must be inside the server root."
+            }))
+            return
+
+        hard_excludes: List[str] = []
+        ignore_patterns: List[str] = []
+        if use_default_excludes:
+            hard_excludes.extend(DEFAULT_EXCLUDE_DIRS)
+            hard_excludes.extend(DEFAULT_EXCLUDE_GLOBS)
+            ignore_patterns.extend(_load_gitignore_patterns(root_dir))
+            repo_root = _get_repo_root(root_dir)
+            if repo_root and repo_root != root_dir:
+                ignore_patterns.extend(_load_gitignore_patterns(repo_root))
+
+        apply_ignore = use_default_excludes and not include_patterns
+        combined_excludes = hard_excludes + user_excludes
+        if apply_ignore:
+            combined_excludes += ignore_patterns
+
+        exclude_dirs, exclude_globs = _classify_excludes(combined_excludes)
+        no_ignore = not apply_ignore
+
+        if action == "replace":
+            if regex_enabled or not case_sensitive:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "success": False,
+                    "error": "Regex or case-insensitive replace is not supported yet."
+                }))
+                return
+            if replace_text is None:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "success": False,
+                    "error": "Replace text is required."
+                }))
+                return
+
+            grep_args = {
+                "pattern": re.escape(query),
+                "path": target_dir,
+                "output_mode": "files_with_matches",
+                "no_ignore": no_ignore,
+                "glob": include_patterns,
+                "exclude_dirs": exclude_dirs,
+                "exclude": exclude_globs,
+            }
+            grep_result = await execute_grep_tool(grep_args)
+            summary, files = _parse_files_response(grep_result)
+            if not files and summary.startswith("Error"):
+                self.set_status(500)
+                self.finish(json.dumps({
+                    "success": False,
+                    "error": summary
+                }))
+                return
+
+            replaced: List[Dict[str, Any]] = []
+            errors: List[Dict[str, str]] = []
+            total_replacements = 0
+
+            for file_path in files:
+                abs_path = file_path if os.path.isabs(file_path) else os.path.abspath(os.path.join(target_dir, file_path))
+                if os.path.commonpath([root_dir, abs_path]) != root_dir:
+                    errors.append({
+                        "file": _to_display_path(file_path, root_dir),
+                        "error": "Path is outside server root."
+                    })
+                    continue
+
+                result = await edit_file_text(
+                    file_path=abs_path,
+                    old_string=query,
+                    new_string=replace_text,
+                    replace_all=True
+                )
+
+                if result.startswith("Success"):
+                    count = _parse_replace_count(result)
+                    total_replacements += count
+                    replaced.append({
+                        "file": _to_display_path(abs_path, root_dir),
+                        "replacements": count
+                    })
+                else:
+                    errors.append({
+                        "file": _to_display_path(abs_path, root_dir),
+                        "error": result
+                    })
+
+            self.finish(json.dumps({
+                "success": True,
+                "summary": summary or f"Updated {len(replaced)} file(s).",
+                "totalFiles": len(files),
+                "totalReplacements": total_replacements,
+                "replaced": replaced,
+                "errors": errors
+            }))
+            return
+
+        limit_raw = payload.get("limit", DEFAULT_MATCH_LIMIT)
+        try:
+            limit = max(1, min(int(limit_raw), MAX_MATCH_LIMIT))
+        except (TypeError, ValueError):
+            limit = DEFAULT_MATCH_LIMIT
+
+        pattern = query if regex_enabled else re.escape(query)
+        grep_args = {
+            "pattern": pattern,
+            "path": target_dir,
+            "output_mode": "content",
+            "head_limit": limit,
+            "no_ignore": no_ignore,
+            "glob": include_patterns,
+            "exclude_dirs": exclude_dirs,
+            "exclude": exclude_globs,
+        }
+        if not case_sensitive:
+            grep_args["i"] = True
+
+        grep_result = await execute_grep_tool(grep_args)
+        summary, matches, truncated = _parse_grep_response(grep_result)
+        if not matches and summary.startswith("Error"):
+            self.set_status(500)
+            self.finish(json.dumps({
+                "success": False,
+                "error": summary
+            }))
+            return
+
+        normalized_matches = []
+        for match in matches:
+            if not isinstance(match, dict):
+                continue
+            file_path = match.get("file", "")
+            normalized_matches.append({
+                "file": _to_display_path(file_path, root_dir),
+                "line_number": match.get("line_number", 0),
+                "content": match.get("content", "")
+            })
+
+        self.finish(json.dumps({
+            "success": True,
+            "summary": summary,
+            "matches": normalized_matches,
+            "truncated": truncated,
+            "limit": limit
+        }))

d5m_ai/tools/grep.py

@@ -28,6 +28,14 @@ def _check_tool_available(tool: str) -> bool:
     return shutil.which(tool) is not None
 
 
+def _normalize_list(value: Any) -> List[str]:
+    if not value:
+        return []
+    if isinstance(value, (list, tuple, set)):
+        return [str(item) for item in value if item]
+    return [str(value)]
+
+
 def _build_ripgrep_command(args: Dict[str, Any], pattern: str, path: str) -> List[str]:
     """Build ripgrep command from arguments."""
     cmd = ['rg', '--json']
@@ -52,10 +60,17 @@ def _build_ripgrep_command(args: Dict[str, Any], pattern: str, path: str) -> Lis
         cmd.append('--count')
     
     # Add file filtering
-    if args.get('glob'):
-        cmd.extend(['--glob', args.get('glob')])
+    for glob in _normalize_list(args.get('glob')):
+        cmd.extend(['--glob', glob])
     if args.get('type'):
         cmd.extend(['--type', args.get('type')])
+
+    exclude_globs = _normalize_list(args.get('exclude'))
+    exclude_dirs = _normalize_list(args.get('exclude_dirs'))
+    for glob in exclude_globs:
+        cmd.extend(['--glob', f'!{glob}'])
+    for directory in exclude_dirs:
+        cmd.extend(['--glob', f'!**/{directory}/**'])
     
     # Add multiline support
     if args.get('multiline'):
@@ -96,9 +111,16 @@ def _build_grep_command(args: Dict[str, Any], pattern: str, path: str) -> List[s
         cmd.append('-c')  # Count mode
     
     # Add file filtering (grep doesn't have direct glob/type support, handled in post-processing)
-    glob_pattern = args.get('glob')
-    if glob_pattern:
-        cmd.extend(['--include', glob_pattern])
+    for glob in _normalize_list(args.get('glob')):
+        cmd.extend(['--include', glob])
+
+    exclude_globs = _normalize_list(args.get('exclude'))
+    for glob in exclude_globs:
+        cmd.extend(['--exclude', glob])
+
+    exclude_dirs = _normalize_list(args.get('exclude_dirs'))
+    for directory in exclude_dirs:
+        cmd.extend(['--exclude-dir', directory])
     
     # Add pattern and path
     cmd.extend(['-E', pattern, path])
@@ -178,12 +200,17 @@ def _parse_grep_output(stdout: str, output_mode: str) -> Tuple[List[Dict[str, An
     return matches, files_with_matches
 
 
-def _should_include_file(file_path: str, glob_pattern: Optional[str], file_type: Optional[str]) -> bool:
+def _should_include_file(file_path: str, glob_pattern: Optional[List[str]], file_type: Optional[str]) -> bool:
     """Check if a file should be included based on glob pattern or file type."""
     if glob_pattern:
         # Handle glob pattern (e.g., "*.py", "**/*.js")
         file_name = os.path.basename(file_path)
-        if not fnmatch.fnmatch(file_name, glob_pattern) and not fnmatch.fnmatch(file_path, glob_pattern):
+        matched = False
+        for glob in glob_pattern:
+            if fnmatch.fnmatch(file_name, glob) or fnmatch.fnmatch(file_path, glob):
+                matched = True
+                break
+        if not matched:
             return False
 
     if file_type:
@@ -195,6 +222,17 @@ def _should_include_file(file_path: str, glob_pattern: Optional[str], file_type:
     return True
 
 
+def _is_excluded(file_path: str, exclude_globs: List[str], exclude_dirs: List[str]) -> bool:
+    normalized = file_path.replace(os.sep, '/')
+    for directory in exclude_dirs:
+        if f'/{directory}/' in f'/{normalized}':
+            return True
+    for glob in exclude_globs:
+        if fnmatch.fnmatch(os.path.basename(normalized), glob) or fnmatch.fnmatch(normalized, glob):
+            return True
+    return False
+
+
 def _python_grep(args: Dict[str, Any], pattern: str, path: str) -> Tuple[List[Dict[str, Any]], List[str]]:
     """
     Pure Python implementation of grep for systems without rg or grep.
@@ -222,9 +260,11 @@ def _python_grep(args: Dict[str, Any], pattern: str, path: str) -> Tuple[List[Di
         after_context = max(after_context, context)
 
     # Get file filters
-    glob_pattern = args.get('glob')
+    glob_pattern = _normalize_list(args.get('glob'))
     file_type = args.get('type')
     head_limit = args.get('head_limit')
+    exclude_globs = _normalize_list(args.get('exclude'))
+    exclude_dirs = _normalize_list(args.get('exclude_dirs'))
 
     # Determine files to search
     search_path = Path(path)
@@ -244,6 +284,9 @@ def _python_grep(args: Dict[str, Any], pattern: str, path: str) -> Tuple[List[Di
 
         file_str = str(file_path)
 
+        if _is_excluded(file_str, exclude_globs, exclude_dirs):
+            continue
+
         # Apply file filters
         if not _should_include_file(file_str, glob_pattern, file_type):
             continue
@@ -356,8 +399,10 @@ async def execute_grep_tool(args: Dict[str, Any]) -> str:
             - B: Number of lines to show before match (optional)
             - C: Number of lines to show before and after match (optional)
             - output_mode: "content", "files_with_matches", or "count" (optional, default: "content")
-            - glob: Glob pattern to filter files (optional)
+            - glob: Glob pattern(s) to filter files (optional)
             - type: File type filter (optional)
+            - exclude: File glob(s) to exclude (optional)
+            - exclude_dirs: Directory name(s) to exclude (optional)
             - head_limit: Limit output to first N results (optional)
             - multiline: Boolean for multiline mode (optional, ripgrep only)
     
@@ -491,4 +536,3 @@ async def execute_grep_tool(args: Dict[str, Any]) -> str:
             "result_type": "error",
             "summary": f"Error executing {tool_name}: {str(e)}"
         })
-

{runcell-0.1.16a0.data → runcell-0.1.16a1.data}/data/share/jupyter/labextensions/runcell/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcell",
-  "version": "0.1.16-alpha.",
+  "version": "0.1.16-alpha.1",
   "description": "AI Agent for Jupyter",
   "keywords": [
     "jupyter",
@@ -71,10 +71,12 @@
     "@jupyterlab/apputils": "^4.5.1",
     "@jupyterlab/completer": "^4.4.2",
     "@jupyterlab/coreutils": "^6.0.0",
+    "@jupyterlab/filebrowser": "^4.0.0",
     "@jupyterlab/launcher": "^4.0.0",
     "@jupyterlab/mainmenu": "^4.0.0",
     "@jupyterlab/notebook": "^4.0.0",
     "@jupyterlab/settingregistry": "^4.0.0",
+    "@jupyterlab/translation": "^4.0.0",
     "@jupyterlab/ui-components": "^4.0.0",
     "@lumino/widgets": "^2.7.1",
     "@mui/material": "^5.15.0",
@@ -85,11 +87,13 @@
     "@radix-ui/react-select": "^2.2.4",
     "@radix-ui/react-slot": "^1.2.2",
     "@radix-ui/react-tabs": "^1.1.12",
+    "@radix-ui/react-toggle": "^1.1.10",
     "@radix-ui/react-tooltip": "^1.2.6",
     "@uiw/react-codemirror": "^4.23.11",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "embla-carousel-react": "^8.6.0",
+    "ignore": "^5.2.0",
     "lucide-react": "^0.507.0",
     "mobx": "^6.13.7",
     "mobx-react-lite": "^4.1.0",
@@ -152,8 +156,9 @@
     "extension": true,
     "outputDir": "d5m_ai/labextension",
     "schemaDir": "schema",
+    "webpackConfig": "webpack.config.js",
     "_build": {
-      "load": "static/remoteEntry.d0ed4a0bca8c2e002f18.js",
+      "load": "static/remoteEntry.ed554ba8c491c35649d1.js",
       "extension": "./extension",
       "style": "./style"
     }

runcell-0.1.16a1.data/data/share/jupyter/labextensions/runcell/schemas/runcell/file-browser-toggle.json

@@ -0,0 +1,22 @@
+{
+    "jupyter.lab.shortcuts": [],
+    "title": "Runcell File Browser Toggle",
+    "description": "Settings for the file browser view switcher.",
+    "type": "object",
+    "properties": {
+        "singleClickToUnfold": {
+            "type": "boolean",
+            "title": "Single click to unfold folders",
+            "description": "If enabled, single click will expand or collapse folders in tree view.",
+            "default": true
+        },
+        "defaultView": {
+            "type": "string",
+            "title": "Default file browser view",
+            "description": "Controls which view is shown when JupyterLab starts.",
+            "enum": ["list", "tree"],
+            "default": "list"
+        }
+    },
+    "additionalProperties": false
+}

{runcell-0.1.16a0.data → runcell-0.1.16a1.data}/data/share/jupyter/labextensions/runcell/schemas/runcell/package.json.orig

@@ -1,6 +1,6 @@
 {
     "name": "runcell",
-    "version": "0.1.16-alpha.",
+    "version": "0.1.16-alpha.1",
     "description": "AI Agent for Jupyter",
     "keywords": [
         "jupyter",
@@ -71,10 +71,12 @@
         "@jupyterlab/apputils": "^4.5.1",
         "@jupyterlab/completer": "^4.4.2",
         "@jupyterlab/coreutils": "^6.0.0",
+        "@jupyterlab/filebrowser": "^4.0.0",
         "@jupyterlab/launcher": "^4.0.0",
         "@jupyterlab/mainmenu": "^4.0.0",
         "@jupyterlab/notebook": "^4.0.0",
         "@jupyterlab/settingregistry": "^4.0.0",
+        "@jupyterlab/translation": "^4.0.0",
         "@jupyterlab/ui-components": "^4.0.0",
         "@lumino/widgets": "^2.7.1",
         "@mui/material": "^5.15.0",
@@ -85,11 +87,13 @@
         "@radix-ui/react-select": "^2.2.4",
         "@radix-ui/react-slot": "^1.2.2",
         "@radix-ui/react-tabs": "^1.1.12",
+        "@radix-ui/react-toggle": "^1.1.10",
         "@radix-ui/react-tooltip": "^1.2.6",
         "@uiw/react-codemirror": "^4.23.11",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "embla-carousel-react": "^8.6.0",
+        "ignore": "^5.2.0",
         "lucide-react": "^0.507.0",
         "mobx": "^6.13.7",
         "mobx-react-lite": "^4.1.0",
@@ -151,7 +155,8 @@
     "jupyterlab": {
         "extension": true,
         "outputDir": "d5m_ai/labextension",
-        "schemaDir": "schema"
+        "schemaDir": "schema",
+        "webpackConfig": "webpack.config.js"
     },
     "eslintIgnore": [
         "node_modules",

runcell-0.1.16a1.data/data/share/jupyter/labextensions/runcell/static/1281.837d5d60e19bb913fcb5.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkruncell=self.webpackChunkruncell||[]).push([[1281],{11281:(t,e,a)=>{a.d(e,{diagram:()=>_});var i,n=a(62799),r=a(45227),d=a(67487),s=a(13888),o=(0,r._)(t=>t.append("circle").attr("class","start-state").attr("r",(0,r.c)().state.sizeUnit).attr("cx",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit).attr("cy",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit),"drawStartState"),c=(0,r._)(t=>t.append("line").style("stroke","grey").style("stroke-dasharray","3").attr("x1",(0,r.c)().state.textHeight).attr("class","divider").attr("x2",2*(0,r.c)().state.textHeight).attr("y1",0).attr("y2",0),"drawDivider"),g=(0,r._)((t,e)=>{const a=t.append("text").attr("x",2*(0,r.c)().state.padding).attr("y",(0,r.c)().state.textHeight+2*(0,r.c)().state.padding).attr("font-size",(0,r.c)().state.fontSize).attr("class","state-title").text(e.id),i=a.node().getBBox();return t.insert("rect",":first-child").attr("x",(0,r.c)().state.padding).attr("y",(0,r.c)().state.padding).attr("width",i.width+2*(0,r.c)().state.padding).attr("height",i.height+2*(0,r.c)().state.padding).attr("rx",(0,r.c)().state.radius),a},"drawSimpleState"),p=(0,r._)((t,e)=>{const a=(0,r._)(function(t,e,a){const i=t.append("tspan").attr("x",2*(0,r.c)().state.padding).text(e);a||i.attr("dy",(0,r.c)().state.textHeight)},"addTspan"),i=t.append("text").attr("x",2*(0,r.c)().state.padding).attr("y",(0,r.c)().state.textHeight+1.3*(0,r.c)().state.padding).attr("font-size",(0,r.c)().state.fontSize).attr("class","state-title").text(e.descriptions[0]).node().getBBox(),n=i.height,d=t.append("text").attr("x",(0,r.c)().state.padding).attr("y",n+.4*(0,r.c)().state.padding+(0,r.c)().state.dividerMargin+(0,r.c)().state.textHeight).attr("class","state-description");let s=!0,o=!0;e.descriptions.forEach(function(t){s||(a(d,t,o),o=!1),s=!1});const c=t.append("line").attr("x1",(0,r.c)().state.padding).attr("y1",(0,r.c)().state.padding+n+(0,r.c)().state.dividerMargin/2).attr("y2",(0,r.c)().state.padding+n+(0,r.c)().state.dividerMargin/2).attr("class","descr-divider"),g=d.node().getBBox(),p=Math.max(g.width,i.width);return c.attr("x2",p+3*(0,r.c)().state.padding),t.insert("rect",":first-child").attr("x",(0,r.c)().state.padding).attr("y",(0,r.c)().state.padding).attr("width",p+2*(0,r.c)().state.padding).attr("height",g.height+n+2*(0,r.c)().state.padding).attr("rx",(0,r.c)().state.radius),t},"drawDescrState"),h=(0,r._)((t,e,a)=>{const i=(0,r.c)().state.padding,n=2*(0,r.c)().state.padding,d=t.node().getBBox(),s=d.width,o=d.x,c=t.append("text").attr("x",0).attr("y",(0,r.c)().state.titleShift).attr("font-size",(0,r.c)().state.fontSize).attr("class","state-title").text(e.id),g=c.node().getBBox().width+n;let p,h=Math.max(g,s);h===s&&(h+=n);const l=t.node().getBBox();e.doc,p=o-i,g>s&&(p=(s-h)/2+i),Math.abs(o-l.x)<i&&g>s&&(p=o-(g-s)/2);const x=1-(0,r.c)().state.textHeight;return t.insert("rect",":first-child").attr("x",p).attr("y",x).attr("class",a?"alt-composit":"composit").attr("width",h).attr("height",l.height+(0,r.c)().state.textHeight+(0,r.c)().state.titleShift+1).attr("rx","0"),c.attr("x",p+i),g<=s&&c.attr("x",o+(h-n)/2-g/2+i),t.insert("rect",":first-child").attr("x",p).attr("y",(0,r.c)().state.titleShift-(0,r.c)().state.textHeight-(0,r.c)().state.padding).attr("width",h).attr("height",3*(0,r.c)().state.textHeight).attr("rx",(0,r.c)().state.radius),t.insert("rect",":first-child").attr("x",p).attr("y",(0,r.c)().state.titleShift-(0,r.c)().state.textHeight-(0,r.c)().state.padding).attr("width",h).attr("height",l.height+3+2*(0,r.c)().state.textHeight).attr("rx",(0,r.c)().state.radius),t},"addTitleAndBox"),l=(0,r._)(t=>(t.append("circle").attr("class","end-state-outer").attr("r",(0,r.c)().state.sizeUnit+(0,r.c)().state.miniPadding).attr("cx",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit+(0,r.c)().state.miniPadding).attr("cy",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit+(0,r.c)().state.miniPadding),t.append("circle").attr("class","end-state-inner").attr("r",(0,r.c)().state.sizeUnit).attr("cx",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit+2).attr("cy",(0,r.c)().state.padding+(0,r.c)().state.sizeUnit+2)),"drawEndState"),x=(0,r._)((t,e)=>{let a=(0,r.c)().state.forkWidth,i=(0,r.c)().state.forkHeight;if(e.parentId){let t=a;a=i,i=t}return t.append("rect").style("stroke","black").style("fill","black").attr("width",a).attr("height",i).attr("x",(0,r.c)().state.padding).attr("y",(0,r.c)().state.padding)},"drawForkJoinState"),u=(0,r._)((t,e,a,i)=>{let n=0;const d=i.append("text");d.style("text-anchor","start"),d.attr("class","noteText");let s=t.replace(/\r\n/g,"<br/>");s=s.replace(/\n/g,"<br/>");const o=s.split(r.k.lineBreakRegex);let c=1.25*(0,r.c)().state.noteMargin;for(const t of o){const i=t.trim();if(i.length>0){const t=d.append("tspan");t.text(i),0===c&&(c+=t.node().getBBox().height),n+=c,t.attr("x",e+(0,r.c)().state.noteMargin),t.attr("y",a+n+1.25*(0,r.c)().state.noteMargin)}}return{textWidth:d.node().getBBox().width,textHeight:n}},"_drawLongText"),f=(0,r._)((t,e)=>{e.attr("class","state-note");const a=e.append("rect").attr("x",0).attr("y",(0,r.c)().state.padding),i=e.append("g"),{textWidth:n,textHeight:d}=u(t,0,0,i);return a.attr("height",d+2*(0,r.c)().state.noteMargin),a.attr("width",n+2*(0,r.c)().state.noteMargin),a},"drawNote"),y=(0,r._)(function(t,e){const a=e.id,i={id:a,label:e.id,width:0,height:0},n=t.append("g").attr("id",a).attr("class","stateGroup");"start"===e.type&&o(n),"end"===e.type&&l(n),("fork"===e.type||"join"===e.type)&&x(n,e),"note"===e.type&&f(e.note.text,n),"divider"===e.type&&c(n),"default"===e.type&&0===e.descriptions.length&&g(n,e),"default"===e.type&&e.descriptions.length>0&&p(n,e);const d=n.node().getBBox();return i.width=d.width+2*(0,r.c)().state.padding,i.height=d.height+2*(0,r.c)().state.padding,i},"drawState"),w=0,b=(0,r._)(function(t,e,a){const i=(0,r._)(function(t){switch(t){case n.S.relationType.AGGREGATION:return"aggregation";case n.S.relationType.EXTENSION:return"extension";case n.S.relationType.COMPOSITION:return"composition";case n.S.relationType.DEPENDENCY:return"dependency"}},"getRelationType");e.points=e.points.filter(t=>!Number.isNaN(t.y));const d=e.points,s=(0,r.a9)().x(function(t){return t.x}).y(function(t){return t.y}).curve(r.aa),o=t.append("path").attr("d",s(d)).attr("id","edge"+w).attr("class","transition");let c="";if((0,r.c)().state.arrowMarkerAbsolute&&(c=(0,r.a6)(!0)),o.attr("marker-end","url("+c+"#"+i(n.S.relationType.DEPENDENCY)+"End)"),void 0!==a.title){const i=t.append("g").attr("class","stateLabel"),{x:n,y:d}=r.u.calcLabelPosition(e.points),s=r.k.getRows(a.title);let o=0;const c=[];let g=0,p=0;for(let t=0;t<=s.length;t++){const e=i.append("text").attr("text-anchor","middle").text(s[t]).attr("x",n).attr("y",d+o),a=e.node().getBBox();g=Math.max(g,a.width),p=Math.min(p,a.x),r.l.info(a.x,n,d+o),0===o&&(o=e.node().getBBox().height,r.l.info("Title height",o,d)),c.push(e)}let h=o*s.length;if(s.length>1){const t=(s.length-1)*o*.5;c.forEach((e,a)=>e.attr("y",d+a*o-t)),h=o*s.length}const l=i.node().getBBox();i.insert("rect",":first-child").attr("class","box").attr("x",n-g/2-(0,r.c)().state.padding/2).attr("y",d-h/2-(0,r.c)().state.padding/2-3.5).attr("width",g+(0,r.c)().state.padding).attr("height",h+(0,r.c)().state.padding),r.l.info(l)}w++},"drawEdge"),B={},m=(0,r._)(function(){},"setConf"),k=(0,r._)(function(t){t.append("defs").append("marker").attr("id","dependencyEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 19,7 L9,13 L14,7 L9,1 Z")},"insertMarkers"),S=(0,r._)(function(t,e,a,n){i=(0,r.c)().state;const d=(0,r.c)().securityLevel;let s;"sandbox"===d&&(s=(0,r.d)("#i"+e));const o="sandbox"===d?(0,r.d)(s.nodes()[0].contentDocument.body):(0,r.d)("body"),c="sandbox"===d?s.nodes()[0].contentDocument:document;r.l.debug("Rendering diagram "+t);const g=o.select(`[id='${e}']`);k(g);const p=n.db.getRootDoc();E(p,g,void 0,!1,o,c,n);const h=i.padding,l=g.node().getBBox(),x=l.width+2*h,u=l.height+2*h,f=1.75*x;(0,r.e)(g,u,f,i.useMaxWidth),g.attr("viewBox",`${l.x-i.padding}  ${l.y-i.padding} `+x+" "+u)},"draw"),N=(0,r._)(t=>t?t.length*i.fontSizeFactor:1,"getLabelWidth"),E=(0,r._)((t,e,a,n,o,c,g)=>{const p=new d.G({compound:!0,multigraph:!0});let l,x=!0;for(l=0;l<t.length;l++)if("relation"===t[l].stmt){x=!1;break}a?p.setGraph({rankdir:"LR",multigraph:!0,compound:!0,ranker:"tight-tree",ranksep:x?1:i.edgeLengthFactor,nodeSep:x?1:50,isMultiGraph:!0}):p.setGraph({rankdir:"TB",multigraph:!0,compound:!0,ranksep:x?1:i.edgeLengthFactor,nodeSep:x?1:50,ranker:"tight-tree",isMultiGraph:!0}),p.setDefaultEdgeLabel(function(){return{}});const u=g.db.getStates(),f=g.db.getRelations(),w=Object.keys(u);for(const t of w){const r=u[t];let d;if(a&&(r.parentId=a),r.doc){let t=e.append("g").attr("id",r.id).attr("class","stateGroup");d=E(r.doc,t,r.id,!n,o,c,g);{t=h(t,r,n);let e=t.node().getBBox();d.width=e.width,d.height=e.height+i.padding/2,B[r.id]={y:i.compositTitleSize}}}else d=y(e,r,p);if(r.note){const t={descriptions:[],id:r.id+"-note",note:r.note,type:"note"},a=y(e,t,p);"left of"===r.note.position?(p.setNode(d.id+"-note",a),p.setNode(d.id,d)):(p.setNode(d.id,d),p.setNode(d.id+"-note",a)),p.setParent(d.id,d.id+"-group"),p.setParent(d.id+"-note",d.id+"-group")}else p.setNode(d.id,d)}r.l.debug("Count=",p.nodeCount(),p);let m=0;f.forEach(function(t){m++,r.l.debug("Setting edge",t),p.setEdge(t.id1,t.id2,{relation:t,width:N(t.title),height:i.labelHeight*r.k.getRows(t.title).length,labelpos:"c"},"id"+m)}),(0,s.l)(p),r.l.debug("Graph after layout",p.nodes());const k=e.node();p.nodes().forEach(function(t){void 0!==t&&void 0!==p.node(t)?(r.l.warn("Node "+t+": "+JSON.stringify(p.node(t))),o.select("#"+k.id+" #"+t).attr("transform","translate("+(p.node(t).x-p.node(t).width/2)+","+(p.node(t).y+(B[t]?B[t].y:0)-p.node(t).height/2)+" )"),o.select("#"+k.id+" #"+t).attr("data-x-shift",p.node(t).x-p.node(t).width/2),c.querySelectorAll("#"+k.id+" #"+t+" .divider").forEach(t=>{const e=t.parentElement;let a=0,i=0;e&&(e.parentElement&&(a=e.parentElement.getBBox().width),i=parseInt(e.getAttribute("data-x-shift"),10),Number.isNaN(i)&&(i=0)),t.setAttribute("x1",0-i+8),t.setAttribute("x2",a-i-8)})):r.l.debug("No Node "+t+": "+JSON.stringify(p.node(t)))});let S=k.getBBox();p.edges().forEach(function(t){void 0!==t&&void 0!==p.edge(t)&&(r.l.debug("Edge "+t.v+" -> "+t.w+": "+JSON.stringify(p.edge(t))),b(e,p.edge(t),p.edge(t).relation))}),S=k.getBBox();const M={id:a||"root",label:a||"root",width:0,height:0};return M.width=S.width+2*i.padding,M.height=S.height+2*i.padding,r.l.debug("Doc rendered",M,p),M},"renderDoc"),M={setConf:m,draw:S},_={parser:n.a,get db(){return new n.S(1)},renderer:M,styles:n.s,init:(0,r._)(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")}}}]);

runcell-0.1.16a1.data/data/share/jupyter/labextensions/runcell/static/1334.557009656e1803272f5a.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkruncell=self.webpackChunkruncell||[]).push([[1334],{51334:(r,e,s)=>{s.d(e,{diagram:()=>c});var a=s(76863),l=s(45227),c={parser:a.a,get db(){return new a.C},renderer:a.c,styles:a.s,init:(0,l._)(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")}}}]);