devdash-mac 0.1.0__py3-none-any.whl

devdash/tools/base64_tool.py

@@ -0,0 +1,79 @@
+"""Base64 encode/decode tool."""
+
+import base64
+import re
+
+from devdash.tools.base import DevTool
+
+_BASE64_RE = re.compile(r"^[A-Za-z0-9+/\n\r]+=*$")
+_BASE64_URLSAFE_RE = re.compile(r"^[A-Za-z0-9_\-\n\r]+=*$")
+
+
+def _is_base64(text: str) -> bool:
+    """Check if text looks like valid Base64."""
+    cleaned = text.strip().replace("\n", "").replace("\r", "")
+    if len(cleaned) < 4 or len(cleaned) % 4 != 0:
+        return False
+    return bool(_BASE64_RE.match(cleaned) or _BASE64_URLSAFE_RE.match(cleaned))
+
+
+class Base64Tool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Base64 Encode / Decode"
+
+    @property
+    def keyword(self) -> str:
+        return "base64"
+
+    @property
+    def category(self) -> str:
+        return "Encoders / Decoders"
+
+    @property
+    def description(self) -> str:
+        return "Encode or decode Base64 (standard and URL-safe)"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return "Error: Empty input."
+
+        mode = str(kwargs.get("mode", "auto"))
+        url_safe = bool(kwargs.get("url_safe", False))
+
+        if mode == "encode":
+            return self._encode(input_text, url_safe)
+        elif mode == "decode":
+            return self._decode(input_text, url_safe)
+        else:
+            # Auto-detect: try decode if it looks like Base64
+            if _is_base64(input_text.strip()):
+                decoded = self._decode(input_text, url_safe)
+                if not decoded.startswith("Error:"):
+                    byte_len = len(input_text.strip().encode())
+                    return f"[Auto-detected Base64 → Decoded]\n{decoded}\n\nBytes: {byte_len}"
+            return self._encode(input_text, url_safe)
+
+    def _encode(self, text: str, url_safe: bool) -> str:
+        data = text.encode("utf-8")
+        if url_safe:
+            encoded = base64.urlsafe_b64encode(data).decode("ascii")
+        else:
+            encoded = base64.b64encode(data).decode("ascii")
+        return f"{encoded}\n\nOriginal bytes: {len(data)}, Encoded bytes: {len(encoded)}"
+
+    def _decode(self, text: str, url_safe: bool) -> str:
+        cleaned = text.strip()
+        try:
+            if url_safe:
+                decoded = base64.urlsafe_b64decode(cleaned)
+            else:
+                decoded = base64.b64decode(cleaned)
+            result = decoded.decode("utf-8")
+            return f"{result}\n\nEncoded bytes: {len(cleaned)}, Decoded bytes: {len(decoded)}"
+        except Exception as e:
+            return f"Error: Could not decode Base64: {e}"
+
+
+def register() -> DevTool:
+    return Base64Tool()

devdash/tools/color_tool.py

@@ -0,0 +1,108 @@
+"""Color converter - HEX, RGB, HSL, HSV."""
+
+import colorsys
+import re
+
+from devdash.tools.base import DevTool
+
+_HEX_RE = re.compile(r"^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$")
+_RGB_RE = re.compile(r"^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$", re.IGNORECASE)
+_HSL_RE = re.compile(r"^hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%?\s*,\s*(\d{1,3})%?\s*\)$", re.IGNORECASE)
+
+
+class ColorTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Color Converter"
+
+    @property
+    def keyword(self) -> str:
+        return "color"
+
+    @property
+    def category(self) -> str:
+        return "Converters"
+
+    @property
+    def description(self) -> str:
+        return "Convert between HEX, RGB, HSL, and HSV color formats"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return (
+                "Error: Empty input. Provide a color (e.g., #FF0000, rgb(255,0,0), hsl(0,100,50))"
+            )
+
+        text = input_text.strip()
+
+        # Try HEX
+        hex_match = _HEX_RE.match(text)
+        if hex_match:
+            hex_val = hex_match.group(1)
+            if len(hex_val) == 3:
+                hex_val = "".join(c * 2 for c in hex_val)
+            r, g, b = int(hex_val[0:2], 16), int(hex_val[2:4], 16), int(hex_val[4:6], 16)
+            return self._format_all(r, g, b)
+
+        # Try RGB
+        rgb_match = _RGB_RE.match(text)
+        if rgb_match:
+            r, g, b = int(rgb_match.group(1)), int(rgb_match.group(2)), int(rgb_match.group(3))
+            if not all(0 <= v <= 255 for v in (r, g, b)):
+                return "Error: RGB values must be between 0 and 255."
+            return self._format_all(r, g, b)
+
+        # Try HSL
+        hsl_match = _HSL_RE.match(text)
+        if hsl_match:
+            h = int(hsl_match.group(1))
+            s = int(hsl_match.group(2))
+            l_val = int(hsl_match.group(3))
+            if not (0 <= h <= 360 and 0 <= s <= 100 and 0 <= l_val <= 100):
+                return "Error: HSL values out of range (H: 0-360, S: 0-100, L: 0-100)."
+            r, g, b = self._hsl_to_rgb(h, s, l_val)
+            return self._format_all(r, g, b)
+
+        # Try plain RGB numbers: "255, 0, 0" or "255 0 0"
+        parts = re.split(r"[,\s]+", text)
+        if len(parts) == 3 and all(p.isdigit() for p in parts):
+            r, g, b = int(parts[0]), int(parts[1]), int(parts[2])
+            if all(0 <= v <= 255 for v in (r, g, b)):
+                return self._format_all(r, g, b)
+
+        return "Error: Unrecognized color format. Use #HEX, rgb(r,g,b), hsl(h,s,l), or r,g,b"
+
+    def _format_all(self, r: int, g: int, b: int) -> str:
+        hex_val = f"#{r:02X}{g:02X}{b:02X}"
+
+        # HSL
+        h_norm, l_norm, s_norm = colorsys.rgb_to_hls(r / 255, g / 255, b / 255)
+        h_deg = round(h_norm * 360)
+        s_pct = round(s_norm * 100)
+        l_pct = round(l_norm * 100)
+
+        # HSV
+        h_norm2, s_norm2, v_norm2 = colorsys.rgb_to_hsv(r / 255, g / 255, b / 255)
+        h_deg2 = round(h_norm2 * 360)
+        s_pct2 = round(s_norm2 * 100)
+        v_pct2 = round(v_norm2 * 100)
+
+        # Complementary color
+        comp_r, comp_g, comp_b = 255 - r, 255 - g, 255 - b
+        comp_hex = f"#{comp_r:02X}{comp_g:02X}{comp_b:02X}"
+
+        return (
+            f"HEX:           {hex_val}\n"
+            f"RGB:           rgb({r}, {g}, {b})\n"
+            f"HSL:           hsl({h_deg}, {s_pct}%, {l_pct}%)\n"
+            f"HSV:           hsv({h_deg2}, {s_pct2}%, {v_pct2}%)\n"
+            f"Complementary: {comp_hex}"
+        )
+
+    def _hsl_to_rgb(self, h: int, s: int, lightness: int) -> tuple[int, int, int]:
+        r, g, b = colorsys.hls_to_rgb(h / 360, lightness / 100, s / 100)
+        return round(r * 255), round(g * 255), round(b * 255)
+
+
+def register() -> DevTool:
+    return ColorTool()

devdash/tools/cron_tool.py

@@ -0,0 +1,137 @@
+"""Cron expression parser and scheduler."""
+
+from datetime import datetime, timezone
+
+from croniter import croniter
+
+from devdash.tools.base import DevTool
+
+PRESETS: dict[str, str] = {
+    "every minute": "* * * * *",
+    "hourly": "0 * * * *",
+    "daily": "0 0 * * *",
+    "weekly": "0 0 * * 1",
+    "monthly": "0 0 1 * *",
+    "yearly": "0 0 1 1 *",
+}
+
+_FIELD_NAMES = ["minute", "hour", "day of month", "month", "day of week"]
+
+
+class CronTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Cron Expression Parser"
+
+    @property
+    def keyword(self) -> str:
+        return "cron"
+
+    @property
+    def category(self) -> str:
+        return "Converters"
+
+    @property
+    def description(self) -> str:
+        return "Parse cron expressions to human-readable descriptions"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            lines = ["Common cron presets:"]
+            for name, expr in PRESETS.items():
+                lines.append(f"  {expr:15s}  {name}")
+            return "\n".join(lines)
+
+        text = input_text.strip()
+
+        # Check if it's a preset name
+        if text.lower() in PRESETS:
+            text = PRESETS[text.lower()]
+
+        # Validate cron expression
+        if not croniter.is_valid(text):
+            return (
+                f"Error: Invalid cron expression '{text}'.\n\n"
+                "Format: minute hour day-of-month month day-of-week\n"
+                "Example: 0 9 * * 1-5 (9 AM on weekdays)"
+            )
+
+        # Human-readable description
+        desc = self._describe(text)
+
+        # Next 5 run times
+        now = datetime.now(timezone.utc)
+        cron = croniter(text, now)
+        next_runs: list[str] = []
+        for _ in range(5):
+            next_dt = cron.get_next(datetime)
+            next_runs.append(f"  {next_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+
+        lines = [
+            f"Expression:  {text}",
+            f"Description: {desc}",
+            "",
+            "Next 5 runs:",
+            *next_runs,
+        ]
+        return "\n".join(lines)
+
+    def _describe(self, expr: str) -> str:
+        """Generate a human-readable description of a cron expression."""
+        parts = expr.split()
+        if len(parts) < 5:
+            return expr
+
+        minute, hour, dom, month, dow = parts[0], parts[1], parts[2], parts[3], parts[4]
+
+        # Common patterns
+        if expr == "* * * * *":
+            return "Every minute"
+        if minute != "*" and hour == "*" and dom == "*" and month == "*" and dow == "*":
+            return f"Every hour at minute {minute}"
+        if minute != "*" and hour != "*" and dom == "*" and month == "*" and dow == "*":
+            return f"At {hour.zfill(2)}:{minute.zfill(2)} every day"
+        if minute != "*" and hour != "*" and dom == "*" and month == "*" and dow != "*":
+            dow_name = self._dow_name(dow)
+            return f"At {hour.zfill(2)}:{minute.zfill(2)} on {dow_name}"
+        if minute != "*" and hour != "*" and dom != "*" and month == "*" and dow == "*":
+            return f"At {hour.zfill(2)}:{minute.zfill(2)} on day {dom} of every month"
+
+        # Generic fallback
+        desc_parts: list[str] = []
+        if minute == "*":
+            desc_parts.append("every minute")
+        else:
+            desc_parts.append(f"at minute {minute}")
+        if hour != "*":
+            desc_parts.append(f"past hour {hour}")
+        if dom != "*":
+            desc_parts.append(f"on day {dom}")
+        if month != "*":
+            desc_parts.append(f"in month {month}")
+        if dow != "*":
+            desc_parts.append(f"on {self._dow_name(dow)}")
+
+        return ", ".join(desc_parts).capitalize()
+
+    def _dow_name(self, dow: str) -> str:
+        names = {
+            "0": "Sunday",
+            "1": "Monday",
+            "2": "Tuesday",
+            "3": "Wednesday",
+            "4": "Thursday",
+            "5": "Friday",
+            "6": "Saturday",
+            "7": "Sunday",
+        }
+        if dow in names:
+            return names[dow]
+        if "-" in dow:
+            start, end = dow.split("-", 1)
+            return f"{names.get(start, start)} to {names.get(end, end)}"
+        return dow
+
+
+def register() -> DevTool:
+    return CronTool()

devdash/tools/hash_tool.py

@@ -0,0 +1,65 @@
+"""Hash generator - MD5, SHA-1, SHA-256, SHA-512, BLAKE2b, HMAC."""
+
+import hashlib
+import hmac
+
+from devdash.tools.base import DevTool
+
+ALGORITHMS = ["md5", "sha1", "sha256", "sha512", "blake2b"]
+
+
+class HashTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Hash Generator"
+
+    @property
+    def keyword(self) -> str:
+        return "hash"
+
+    @property
+    def category(self) -> str:
+        return "Encoders / Decoders"
+
+    @property
+    def description(self) -> str:
+        return "Generate MD5, SHA-1, SHA-256, SHA-512, BLAKE2b hashes"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return "Error: Empty input. Please provide text to hash."
+
+        algorithm = str(kwargs.get("algorithm", "all"))
+        hmac_key = kwargs.get("key")
+
+        data = input_text.encode("utf-8")
+
+        if hmac_key:
+            return self._hmac_hash(data, str(hmac_key), algorithm)
+
+        if algorithm != "all" and algorithm in ALGORITHMS:
+            h = hashlib.new(algorithm, data)
+            return f"{algorithm.upper()}: {h.hexdigest()}"
+
+        lines: list[str] = []
+        for algo in ALGORITHMS:
+            h = hashlib.new(algo, data)
+            lines.append(f"{algo.upper():>8}: {h.hexdigest()}")
+        return "\n".join(lines)
+
+    def _hmac_hash(self, data: bytes, key: str, algorithm: str) -> str:
+        key_bytes = key.encode("utf-8")
+        if algorithm == "all":
+            algorithm = "sha256"
+        if algorithm not in ALGORITHMS:
+            return f"Error: Unknown algorithm '{algorithm}'. Use: {', '.join(ALGORITHMS)}"
+        if algorithm == "blake2b":
+            # HMAC doesn't support blake2b directly, use hashlib
+            h = hmac.new(key_bytes, data, hashlib.sha256)
+            return f"HMAC-SHA256 (blake2b not supported for HMAC): {h.hexdigest()}"
+        h = hmac.new(key_bytes, data, algorithm)
+        return f"HMAC-{algorithm.upper()}: {h.hexdigest()}"
+
+
+def register() -> DevTool:
+    return HashTool()

devdash/tools/json_tool.py

@@ -0,0 +1,61 @@
+"""JSON formatter, validator, and minifier."""
+
+import json
+
+from devdash.tools.base import DevTool
+
+
+class JsonTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "JSON Formatter"
+
+    @property
+    def keyword(self) -> str:
+        return "json"
+
+    @property
+    def category(self) -> str:
+        return "Formatters"
+
+    @property
+    def description(self) -> str:
+        return "Format, validate, or minify JSON"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return "Error: Empty input. Please provide a JSON string."
+
+        mode = str(kwargs.get("mode", "format"))
+
+        if mode == "validate":
+            return self._validate_json(input_text)
+        elif mode == "minify":
+            return self._minify(input_text)
+        else:
+            return self._format(input_text)
+
+    def _format(self, text: str) -> str:
+        try:
+            parsed = json.loads(text)
+            return json.dumps(parsed, indent=2, ensure_ascii=False)
+        except json.JSONDecodeError as e:
+            return f"Invalid JSON: {e.msg} (line {e.lineno}, column {e.colno})"
+
+    def _minify(self, text: str) -> str:
+        try:
+            parsed = json.loads(text)
+            return json.dumps(parsed, separators=(",", ":"), ensure_ascii=False)
+        except json.JSONDecodeError as e:
+            return f"Invalid JSON: {e.msg} (line {e.lineno}, column {e.colno})"
+
+    def _validate_json(self, text: str) -> str:
+        try:
+            json.loads(text)
+            return "Valid JSON"
+        except json.JSONDecodeError as e:
+            return f"Invalid JSON: {e.msg} (line {e.lineno}, column {e.colno})"
+
+
+def register() -> DevTool:
+    return JsonTool()

devdash/tools/jwt_tool.py

@@ -0,0 +1,97 @@
+"""JWT decoder - decode header and payload without verification."""
+
+import json
+from datetime import datetime, timezone
+
+import jwt
+
+from devdash.tools.base import DevTool
+
+
+class JwtTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "JWT Decoder"
+
+    @property
+    def keyword(self) -> str:
+        return "jwt"
+
+    @property
+    def category(self) -> str:
+        return "Encoders / Decoders"
+
+    @property
+    def description(self) -> str:
+        return "Decode JWT tokens (header + payload + expiry check)"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return "Error: Empty input. Please provide a JWT token."
+
+        token = input_text.strip()
+
+        parts = token.split(".")
+        if len(parts) != 3:
+            return (
+                "Error: Invalid JWT format. "
+                f"Expected 3 parts (header.payload.signature), got {len(parts)}."
+            )
+
+        try:
+            header = jwt.get_unverified_header(token)
+        except jwt.exceptions.DecodeError as e:
+            return f"Error: Could not decode JWT header: {e}"
+
+        try:
+            algorithms = [
+                "HS256",
+                "HS384",
+                "HS512",
+                "RS256",
+                "RS384",
+                "RS512",
+                "ES256",
+                "ES384",
+                "ES512",
+            ]
+            payload = jwt.decode(token, options={"verify_signature": False}, algorithms=algorithms)
+        except jwt.exceptions.DecodeError as e:
+            return f"Error: Could not decode JWT payload: {e}"
+
+        lines: list[str] = []
+        lines.append("=== HEADER ===")
+        lines.append(json.dumps(header, indent=2))
+        lines.append("")
+        lines.append("=== PAYLOAD ===")
+        lines.append(json.dumps(payload, indent=2, default=str))
+
+        # Expiration check
+        exp = payload.get("exp")
+        iat = payload.get("iat")
+        now = datetime.now(timezone.utc)
+
+        lines.append("")
+        lines.append("=== TOKEN INFO ===")
+
+        if iat:
+            issued = datetime.fromtimestamp(iat, tz=timezone.utc)
+            lines.append(f"Issued At:  {issued.isoformat()}")
+
+        if exp:
+            expiry = datetime.fromtimestamp(exp, tz=timezone.utc)
+            is_expired = now > expiry
+            lines.append(f"Expires At: {expiry.isoformat()}")
+            status = "*** EXPIRED ***" if is_expired else "Valid (not expired)"
+            lines.append(f"Status:     {status}")
+        else:
+            lines.append("Expires At: No expiration set")
+
+        lines.append("")
+        lines.append("WARNING: This tool only DECODES the token. It does NOT verify the signature.")
+
+        return "\n".join(lines)
+
+
+def register() -> DevTool:
+    return JwtTool()

devdash/tools/lorem_tool.py

@@ -0,0 +1,102 @@
+"""Lorem ipsum generator."""
+
+from devdash.tools.base import DevTool
+
+_LOREM_TEXT = (
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor "
+    "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud "
+    "exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure "
+    "dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. "
+    "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt "
+    "mollit anim id est laborum."
+)
+
+_SENTENCES = [
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+    "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+    "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.",
+    "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore.",
+    "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia.",
+    "Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit.",
+    "Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet.",
+    "Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis.",
+    "Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse.",
+    "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis.",
+    "Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit.",
+    "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus.",
+]
+
+_WORDS = _LOREM_TEXT.replace(",", "").replace(".", "").lower().split()
+
+
+class LoremTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Lorem Ipsum Generator"
+
+    @property
+    def keyword(self) -> str:
+        return "lorem"
+
+    @property
+    def category(self) -> str:
+        return "Generators"
+
+    @property
+    def description(self) -> str:
+        return "Generate lorem ipsum text by words, sentences, or paragraphs"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        text = input_text.strip().lower()
+        mode = str(kwargs.get("mode", ""))
+
+        if not text and not mode:
+            return self._paragraphs(3)
+
+        # Parse "5 words", "3 sentences", "2 paragraphs" or just a number
+        parts = text.split()
+        count = 1
+        unit = mode or "paragraphs"
+
+        if parts:
+            try:
+                count = int(parts[0])
+            except ValueError:
+                pass
+            if len(parts) > 1:
+                unit = parts[1].rstrip("s") + "s" if not parts[1].endswith("s") else parts[1]
+
+        count = max(1, min(count, 100))
+
+        if unit.startswith("word"):
+            return self._words(count)
+        elif unit.startswith("sentence"):
+            return self._sentences(count)
+        else:
+            return self._paragraphs(count)
+
+    def _words(self, count: int) -> str:
+        result: list[str] = []
+        while len(result) < count:
+            result.extend(_WORDS)
+        return " ".join(result[:count]).capitalize() + "."
+
+    def _sentences(self, count: int) -> str:
+        result: list[str] = []
+        idx = 0
+        while len(result) < count:
+            result.append(_SENTENCES[idx % len(_SENTENCES)])
+            idx += 1
+        return " ".join(result[:count])
+
+    def _paragraphs(self, count: int) -> str:
+        paragraphs: list[str] = []
+        for i in range(count):
+            start = (i * 3) % len(_SENTENCES)
+            sents = [_SENTENCES[(start + j) % len(_SENTENCES)] for j in range(4)]
+            paragraphs.append(" ".join(sents))
+        return "\n\n".join(paragraphs)
+
+
+def register() -> DevTool:
+    return LoremTool()