clidevkit 0.1.0__py3-none-any.whl

clidev/themes.py

@@ -0,0 +1,96 @@
+"""Theming support for clidev applications."""
+
+from .colors import resolve
+
+
+class Theme:
+    """A mutable theme object.
+
+    Usage:
+        theme = Theme()
+        theme.primary("blue")
+        theme.success("green")
+
+    Or start from a built-in preset:
+        theme = Theme.preset("dark")
+    """
+
+    _DEFAULTS = {
+        "primary": "cyan",
+        "secondary": "blue",
+        "success": "green",
+        "warning": "yellow",
+        "error": "red",
+        "info": "cyan",
+        "text": "white",
+        "muted": "gray",
+        "background": "black",
+        "accent": "magenta",
+    }
+
+    def __init__(self):
+        self._colors = dict(self._DEFAULTS)
+
+    # --- fluent setters -------------------------------------------------
+    def _set(self, key, color):
+        self._colors[key] = resolve(color)
+        return self
+
+    def primary(self, color):
+        return self._set("primary", color)
+
+    def secondary(self, color):
+        return self._set("secondary", color)
+
+    def success(self, color):
+        return self._set("success", color)
+
+    def warning(self, color):
+        return self._set("warning", color)
+
+    def error(self, color):
+        return self._set("error", color)
+
+    def info(self, color):
+        return self._set("info", color)
+
+    def text(self, color):
+        return self._set("text", color)
+
+    def muted(self, color):
+        return self._set("muted", color)
+
+    def background(self, color):
+        return self._set("background", color)
+
+    def accent(self, color):
+        return self._set("accent", color)
+
+    # --- access -----------------------------------------------------------
+    def get(self, key, fallback=None):
+        return self._colors.get(key, fallback)
+
+    def __getitem__(self, key):
+        return self._colors[key]
+
+    def as_dict(self):
+        return dict(self._colors)
+
+    @classmethod
+    def preset(cls, name: str) -> "Theme":
+        theme = cls()
+        if name == "dark":
+            theme.primary("cyan").secondary("blue").success("green")
+            theme.warning("yellow").error("red").text("white")
+            theme.muted("gray").background("black").accent("magenta")
+        elif name == "light":
+            theme.primary("blue").secondary("purple").success("green")
+            theme.warning("orange").error("red").text("black")
+            theme.muted("gray").background("white").accent("magenta")
+        else:
+            # Unknown theme name -> defaults
+            pass
+        return theme
+
+    def __repr__(self):
+        return f"Theme({self._colors})"

clidev/tree.py

@@ -0,0 +1,36 @@
+"""Tree rendering widget, wraps rich.tree.Tree."""
+
+from rich.console import Console
+from rich.tree import Tree as RichTree
+
+
+class TreeNode:
+    def __init__(self, label: str):
+        self.label = label
+        self.children: list["TreeNode"] = []
+
+    def add(self, label: str) -> "TreeNode":
+        node = TreeNode(label)
+        self.children.append(node)
+        return node
+
+    def _build(self, rich_node):
+        for child in self.children:
+            branch = rich_node.add(child.label)
+            child._build(branch)
+
+
+class Tree:
+    """app.tree("Project"); root.add("src").add("main.py")"""
+
+    def __init__(self, label: str):
+        self.root = TreeNode(label)
+        self._console = Console()
+
+    def add(self, label: str) -> TreeNode:
+        return self.root.add(label)
+
+    def show(self):
+        rich_tree = RichTree(self.root.label)
+        self.root._build(rich_tree)
+        self._console.print(rich_tree)

clidev/utils.py

@@ -0,0 +1,20 @@
+"""Small shared utility helpers."""
+
+import re
+
+
+def slugify(text: str) -> str:
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    return text.strip("_")
+
+
+def truncate(text: str, length: int = 40) -> str:
+    return text if len(text) <= length else text[: length - 1] + "\u2026"
+
+
+def merge_dicts(*dicts: dict) -> dict:
+    result = {}
+    for d in dicts:
+        result.update(d)
+    return result

clidev/validators.py

@@ -0,0 +1,90 @@
+"""Built-in field validators used by forms.py / inputs.py."""
+
+import re
+from datetime import datetime
+
+from .exceptions import ValidationError
+
+EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+URL_RE = re.compile(r"^(https?|ftp)://[^\s/$.?#].[^\s]*$", re.IGNORECASE)
+
+
+def required(value):
+    if value is None or (isinstance(value, str) and value.strip() == ""):
+        raise ValidationError("This field is required.")
+    return value
+
+
+def is_email(value):
+    if value and not EMAIL_RE.match(value):
+        raise ValidationError("Enter a valid email address.")
+    return value
+
+
+def is_url(value):
+    if value and not URL_RE.match(value):
+        raise ValidationError("Enter a valid URL.")
+    return value
+
+
+def is_number(value):
+    try:
+        if isinstance(value, (int, float)):
+            return value
+        return float(value) if "." in str(value) else int(value)
+    except (ValueError, TypeError) as e:
+        raise ValidationError("Enter a valid number.") from e
+
+
+def min_length(n):
+    def _validator(value):
+        if value is not None and len(str(value)) < n:
+            raise ValidationError(f"Must be at least {n} characters.")
+        return value
+
+    return _validator
+
+
+def max_length(n):
+    def _validator(value):
+        if value is not None and len(str(value)) > n:
+            raise ValidationError(f"Must be at most {n} characters.")
+        return value
+
+    return _validator
+
+
+def min_value(n):
+    def _validator(value):
+        if value is not None and float(value) < n:
+            raise ValidationError(f"Must be at least {n}.")
+        return value
+
+    return _validator
+
+
+def max_value(n):
+    def _validator(value):
+        if value is not None and float(value) > n:
+            raise ValidationError(f"Must be at most {n}.")
+        return value
+
+    return _validator
+
+
+def is_date(fmt="%Y-%m-%d"):
+    def _validator(value):
+        try:
+            datetime.strptime(str(value), fmt)
+        except ValueError as e:
+            raise ValidationError(f"Enter a valid date ({fmt}).") from e
+        return value
+
+    return _validator
+
+
+def run_validators(value, validators):
+    """Run a list of validator callables against value, raising on first failure."""
+    for validator in validators:
+        value = validator(value)
+    return value

clidev/workflow.py

@@ -0,0 +1,52 @@
+"""Sequential step-based workflow engine."""
+
+from .exceptions import WorkflowError
+
+
+class Workflow:
+    """A sequence of steps run in order, sharing a context dict between them.
+
+    workflow = app.workflow()
+    workflow.step(login)
+    workflow.step(select_project)
+    workflow.step(build)
+    workflow.step(deploy)
+    workflow.start()
+
+    Each step function may optionally accept a single `context` dict argument;
+    its return value (if a dict) is merged into the shared context for
+    subsequent steps.
+    """
+
+    def __init__(self, app=None, name: str = "workflow"):
+        self.app = app
+        self.name = name
+        self.steps: list = []
+        self.context: dict = {}
+
+    def step(self, fn) -> "Workflow":
+        self.steps.append(fn)
+        return self
+
+    def start(self, initial_context: dict | None = None):
+        self.context = dict(initial_context or {})
+        for i, fn in enumerate(self.steps):
+            try:
+                result = self._call_step(fn)
+            except Exception as e:
+                if self.app is not None:
+                    self.app.events.emit("error", e)
+                raise WorkflowError(
+                    f"Workflow '{self.name}' failed at step {i} ({getattr(fn, '__name__', fn)}): {e}"
+                ) from e
+            if isinstance(result, dict):
+                self.context.update(result)
+        return self.context
+
+    def _call_step(self, fn):
+        import inspect
+
+        sig = inspect.signature(fn)
+        if len(sig.parameters) >= 1:
+            return fn(self.context)
+        return fn()