devdash-mac 0.1.0__py3-none-any.whl

devdash/tools/password_tool.py

@@ -0,0 +1,366 @@
+"""Secure password generator using secrets module."""
+
+import math
+import secrets
+import string
+
+from devdash.tools.base import DevTool
+
+# Word list for passphrases (common English words)
+_WORDLIST = [
+    "abandon",
+    "ability",
+    "able",
+    "about",
+    "above",
+    "absent",
+    "absorb",
+    "abstract",
+    "absurd",
+    "abuse",
+    "access",
+    "accident",
+    "account",
+    "accuse",
+    "achieve",
+    "acid",
+    "acquire",
+    "across",
+    "action",
+    "actor",
+    "actress",
+    "actual",
+    "adapt",
+    "address",
+    "adjust",
+    "admit",
+    "adult",
+    "advance",
+    "advice",
+    "aerobic",
+    "afford",
+    "afraid",
+    "again",
+    "agent",
+    "agree",
+    "ahead",
+    "alarm",
+    "album",
+    "alert",
+    "alien",
+    "allow",
+    "almost",
+    "alone",
+    "alpha",
+    "already",
+    "also",
+    "alter",
+    "always",
+    "amateur",
+    "amazing",
+    "among",
+    "amount",
+    "amused",
+    "anchor",
+    "ancient",
+    "anger",
+    "angle",
+    "animal",
+    "annual",
+    "answer",
+    "apart",
+    "apple",
+    "approve",
+    "arctic",
+    "arena",
+    "armor",
+    "army",
+    "arrow",
+    "artist",
+    "assign",
+    "assist",
+    "atom",
+    "attack",
+    "attend",
+    "august",
+    "aunt",
+    "author",
+    "auto",
+    "autumn",
+    "average",
+    "avocado",
+    "avoid",
+    "awake",
+    "aware",
+    "awesome",
+    "badge",
+    "balance",
+    "bamboo",
+    "banana",
+    "banner",
+    "barrel",
+    "basket",
+    "battle",
+    "beach",
+    "beauty",
+    "become",
+    "before",
+    "begin",
+    "behind",
+    "believe",
+    "bench",
+    "benefit",
+    "bicycle",
+    "blade",
+    "blanket",
+    "blast",
+    "bless",
+    "blind",
+    "blood",
+    "blossom",
+    "board",
+    "bonus",
+    "border",
+    "bottle",
+    "bounce",
+    "brave",
+    "breeze",
+    "bridge",
+    "bright",
+    "broken",
+    "brother",
+    "budget",
+    "bundle",
+    "burger",
+    "butter",
+    "cabin",
+    "cable",
+    "camera",
+    "campus",
+    "canal",
+    "cancel",
+    "candy",
+    "cannon",
+    "canvas",
+    "canyon",
+    "captain",
+    "carbon",
+    "carpet",
+    "castle",
+    "catalog",
+    "catch",
+    "cattle",
+    "caught",
+    "cause",
+    "ceiling",
+    "celery",
+    "cement",
+    "census",
+    "century",
+    "cereal",
+    "certain",
+    "chair",
+    "chalk",
+    "champion",
+    "change",
+    "chapter",
+    "charge",
+    "chase",
+    "cherry",
+    "chicken",
+    "choice",
+    "circle",
+    "citizen",
+    "civil",
+    "claim",
+    "clap",
+    "clarify",
+    "clean",
+    "clever",
+    "climate",
+    "clinic",
+    "clock",
+    "close",
+    "cloud",
+    "cluster",
+    "coach",
+    "coconut",
+    "coffee",
+    "collect",
+    "color",
+    "column",
+    "combine",
+    "comfort",
+    "comic",
+    "common",
+    "company",
+    "concert",
+    "conduct",
+    "confirm",
+    "congress",
+    "connect",
+    "consider",
+    "control",
+    "convince",
+    "cookie",
+    "copper",
+    "coral",
+    "correct",
+    "cotton",
+    "country",
+    "couple",
+    "course",
+    "cousin",
+    "cover",
+    "cradle",
+    "craft",
+    "cream",
+    "credit",
+    "creek",
+    "crew",
+    "crisis",
+    "cross",
+    "crowd",
+    "crucial",
+    "cruel",
+    "cruise",
+    "crystal",
+    "cube",
+    "culture",
+    "current",
+    "curtain",
+    "custom",
+    "cycle",
+    "damage",
+    "dance",
+    "danger",
+    "daughter",
+    "dawn",
+    "debate",
+    "decade",
+    "december",
+    "decide",
+    "decline",
+    "decorate",
+    "decrease",
+    "defense",
+    "define",
+    "degree",
+    "delay",
+    "deliver",
+    "demand",
+    "denial",
+    "dentist",
+    "deny",
+    "depart",
+    "depend",
+    "deposit",
+    "describe",
+    "desert",
+    "design",
+    "detail",
+    "detect",
+    "develop",
+    "device",
+    "devote",
+    "diagram",
+    "diamond",
+    "diary",
+    "diesel",
+    "differ",
+    "digital",
+    "dignity",
+    "dilemma",
+    "dinner",
+    "dinosaur",
+    "direct",
+    "discover",
+    "dismiss",
+    "display",
+    "distance",
+    "divide",
+    "doctor",
+    "document",
+    "dolphin",
+    "domain",
+    "donate",
+    "donkey",
+    "double",
+    "dragon",
+]
+
+
+class PasswordTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Password Generator"
+
+    @property
+    def keyword(self) -> str:
+        return "password"
+
+    @property
+    def category(self) -> str:
+        return "Generators"
+
+    @property
+    def description(self) -> str:
+        return "Generate secure passwords or passphrases"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        text = input_text.strip().lower()
+        mode = str(kwargs.get("mode", ""))
+
+        if text == "passphrase" or mode == "passphrase":
+            word_count = int(kwargs.get("words", 4))
+            return self._passphrase(max(2, min(word_count, 12)))
+
+        length = 16
+        if text.isdigit():
+            length = int(text)
+        elif kwargs.get("length"):
+            length = int(kwargs["length"])  # type: ignore[arg-type]
+
+        length = max(8, min(length, 128))
+
+        include_upper = bool(kwargs.get("uppercase", True))
+        include_lower = bool(kwargs.get("lowercase", True))
+        include_digits = bool(kwargs.get("digits", True))
+        include_symbols = bool(kwargs.get("symbols", True))
+        count = int(kwargs.get("count", 1))
+        count = max(1, min(count, 20))
+
+        charset = ""
+        if include_lower:
+            charset += string.ascii_lowercase
+        if include_upper:
+            charset += string.ascii_uppercase
+        if include_digits:
+            charset += string.digits
+        if include_symbols:
+            charset += string.punctuation
+        if not charset:
+            charset = string.ascii_letters + string.digits
+
+        results: list[str] = []
+        for _ in range(count):
+            password = "".join(secrets.choice(charset) for _ in range(length))
+            entropy = self._entropy(length, len(charset))
+            results.append(f"{password}  (entropy: {entropy:.0f} bits)")
+
+        return "\n".join(results)
+
+    def _passphrase(self, word_count: int) -> str:
+        words = [secrets.choice(_WORDLIST) for _ in range(word_count)]
+        passphrase = "-".join(words)
+        entropy = math.log2(len(_WORDLIST)) * word_count
+        return f"{passphrase}\n\nWords: {word_count}, Entropy: {entropy:.0f} bits"
+
+    def _entropy(self, length: int, charset_size: int) -> float:
+        if charset_size <= 0:
+            return 0.0
+        return length * math.log2(charset_size)
+
+
+def register() -> DevTool:
+    return PasswordTool()

devdash/tools/regex_tool.py

@@ -0,0 +1,88 @@
+"""Regex tester with match highlighting and common presets."""
+
+import re
+
+from devdash.tools.base import DevTool
+
+PRESETS: dict[str, str] = {
+    "email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
+    "url": r"https?://[^\s<>\"]+",
+    "ipv4": r"\b(?:\d{1,3}\.){3}\d{1,3}\b",
+    "phone": r"\+?[\d\s\-().]{7,15}",
+    "date": r"\d{4}-\d{2}-\d{2}",
+}
+
+
+class RegexTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Regex Tester"
+
+    @property
+    def keyword(self) -> str:
+        return "regex"
+
+    @property
+    def category(self) -> str:
+        return "Testers"
+
+    @property
+    def description(self) -> str:
+        return "Test regex patterns with match highlighting"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        # Check kwargs first
+        pattern = str(kwargs.get("pattern", ""))
+        test_string = str(kwargs.get("test_string", ""))
+
+        if not input_text.strip() and not pattern:
+            return "Error: Empty input. Provide pattern and test string separated by \\n---\\n"
+
+        if not pattern:
+            parts = input_text.split("\n---\n", maxsplit=1)
+            if len(parts) == 2:
+                pattern = parts[0].strip()
+                test_string = parts[1]
+            else:
+                # Try first line as pattern, rest as test string
+                lines = input_text.split("\n", maxsplit=1)
+                pattern = lines[0].strip()
+                test_string = lines[1] if len(lines) > 1 else ""
+
+        if not pattern:
+            return "Error: No regex pattern provided."
+        if not test_string:
+            return "Error: No test string provided."
+
+        # Check for preset
+        if pattern.lower() in PRESETS:
+            pattern = PRESETS[pattern.lower()]
+
+        try:
+            compiled = re.compile(pattern)
+        except re.error as e:
+            return f"Error: Invalid regex pattern: {e}"
+
+        matches = list(compiled.finditer(test_string))
+
+        if not matches:
+            return f"Pattern: {pattern}\nNo matches found."
+
+        lines = [f"Pattern: {pattern}", f"Matches: {len(matches)}", ""]
+
+        for i, match in enumerate(matches, 1):
+            lines.append(f"Match {i}: '{match.group()}' (position {match.start()}-{match.end()})")
+            groups = match.groups()
+            if groups:
+                for j, g in enumerate(groups, 1):
+                    lines.append(f"  Group {j}: '{g}'")
+            named = match.groupdict()
+            if named:
+                for name, val in named.items():
+                    lines.append(f"  Named '{name}': '{val}'")
+
+        return "\n".join(lines)
+
+
+def register() -> DevTool:
+    return RegexTool()

devdash/tools/timestamp_tool.py

@@ -0,0 +1,142 @@
+"""Unix timestamp <-> human date converter."""
+
+import re
+from datetime import datetime, timezone
+
+from devdash.tools.base import DevTool
+
+
+def _relative_time(dt: datetime) -> str:
+    """Return human-friendly relative time string."""
+    now = datetime.now(timezone.utc)
+    diff = now - dt
+    seconds = int(diff.total_seconds())
+
+    if seconds < 0:
+        return _relative_future(-seconds)
+
+    if seconds < 60:
+        return f"{seconds} seconds ago"
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"{minutes} minute{'s' if minutes != 1 else ''} ago"
+    hours = minutes // 60
+    if hours < 24:
+        return f"{hours} hour{'s' if hours != 1 else ''} ago"
+    days = hours // 24
+    if days < 30:
+        return f"{days} day{'s' if days != 1 else ''} ago"
+    months = days // 30
+    if months < 12:
+        return f"{months} month{'s' if months != 1 else ''} ago"
+    years = days // 365
+    return f"{years} year{'s' if years != 1 else ''} ago"
+
+
+def _relative_future(seconds: int) -> str:
+    if seconds < 60:
+        return f"in {seconds} seconds"
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"in {minutes} minute{'s' if minutes != 1 else ''}"
+    hours = minutes // 60
+    if hours < 24:
+        return f"in {hours} hour{'s' if hours != 1 else ''}"
+    days = hours // 24
+    return f"in {days} day{'s' if days != 1 else ''}"
+
+
+class TimestampTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "Timestamp Converter"
+
+    @property
+    def keyword(self) -> str:
+        return "timestamp"
+
+    @property
+    def category(self) -> str:
+        return "Converters"
+
+    @property
+    def description(self) -> str:
+        return "Convert between Unix timestamps and human-readable dates"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            # Show current timestamp
+            now = datetime.now(timezone.utc)
+            ts = int(now.timestamp())
+            return f"Current time:\nUnix: {ts}\nUTC:  {now.strftime('%Y-%m-%d %H:%M:%S UTC')}"
+
+        text = input_text.strip()
+
+        # Auto-detect: if pure digits, treat as timestamp
+        if re.match(r"^\d{10,13}$", text):
+            return self._from_timestamp(text)
+        else:
+            return self._to_timestamp(text)
+
+    def _from_timestamp(self, text: str) -> str:
+        ts = int(text)
+        is_millis = len(text) == 13
+        if is_millis:
+            ts_seconds = ts / 1000
+        else:
+            ts_seconds = float(ts)
+
+        try:
+            dt = datetime.fromtimestamp(ts_seconds, tz=timezone.utc)
+        except (OSError, OverflowError, ValueError):
+            return f"Error: Timestamp {text} is out of valid range."
+
+        local_tz = datetime.now().astimezone().tzinfo
+        local_dt = dt.astimezone(local_tz)
+
+        lines = [
+            f"Input: {text} ({'milliseconds' if is_millis else 'seconds'})",
+            "",
+            f"UTC:   {dt.strftime('%Y-%m-%d %H:%M:%S %Z')}",
+            f"Local: {local_dt.strftime('%Y-%m-%d %H:%M:%S %Z')}",
+            "",
+            f"Relative: {_relative_time(dt)}",
+            f"ISO 8601: {dt.isoformat()}",
+        ]
+        return "\n".join(lines)
+
+    def _to_timestamp(self, text: str) -> str:
+        formats = [
+            "%Y-%m-%d %H:%M:%S",
+            "%Y-%m-%dT%H:%M:%S",
+            "%Y-%m-%dT%H:%M:%SZ",
+            "%Y-%m-%d",
+            "%d/%m/%Y %H:%M:%S",
+            "%d/%m/%Y",
+            "%m/%d/%Y",
+        ]
+
+        dt = None
+        for fmt in formats:
+            try:
+                dt = datetime.strptime(text, fmt).replace(tzinfo=timezone.utc)
+                break
+            except ValueError:
+                continue
+
+        if dt is None:
+            return f"Error: Could not parse date '{text}'. Supported formats:\n" + "\n".join(
+                f"  {f}" for f in formats
+            )
+
+        ts = int(dt.timestamp())
+        ts_ms = ts * 1000
+        return (
+            f"Unix (seconds):      {ts}\n"
+            f"Unix (milliseconds): {ts_ms}\n"
+            f"ISO 8601:            {dt.isoformat()}"
+        )
+
+
+def register() -> DevTool:
+    return TimestampTool()

devdash/tools/url_tool.py

@@ -0,0 +1,75 @@
+"""URL encode/decode and parser."""
+
+from urllib.parse import parse_qs, quote, unquote, urlparse
+
+from devdash.tools.base import DevTool
+
+
+class UrlTool(DevTool):
+    @property
+    def name(self) -> str:
+        return "URL Encode / Decode"
+
+    @property
+    def keyword(self) -> str:
+        return "url"
+
+    @property
+    def category(self) -> str:
+        return "Encoders / Decoders"
+
+    @property
+    def description(self) -> str:
+        return "URL encode/decode and parse URL components"
+
+    def process(self, input_text: str, **kwargs: object) -> str:
+        if not input_text.strip():
+            return "Error: Empty input."
+
+        text = input_text.strip()
+        mode = str(kwargs.get("mode", "auto"))
+
+        if mode == "encode":
+            return self._encode(text)
+        elif mode == "decode":
+            return self._decode(text)
+        elif mode == "parse":
+            return self._parse(text)
+        else:
+            # Auto-detect
+            if text.startswith(("http://", "https://")):
+                return self._parse(text)
+            if "%" in text:
+                return f"[Decoded]\n{self._decode(text)}"
+            return f"[Encoded]\n{self._encode(text)}"
+
+    def _encode(self, text: str) -> str:
+        return quote(text, safe="")
+
+    def _decode(self, text: str) -> str:
+        return unquote(text)
+
+    def _parse(self, text: str) -> str:
+        parsed = urlparse(text)
+        params = parse_qs(parsed.query)
+
+        lines = [
+            f"Scheme:   {parsed.scheme or '(none)'}",
+            f"Host:     {parsed.hostname or '(none)'}",
+            f"Port:     {parsed.port or '(default)'}",
+            f"Path:     {parsed.path or '/'}",
+            f"Query:    {parsed.query or '(none)'}",
+            f"Fragment: {parsed.fragment or '(none)'}",
+        ]
+
+        if params:
+            lines.append("\nQuery Parameters:")
+            for key, values in params.items():
+                for val in values:
+                    lines.append(f"  {key} = {val}")
+
+        return "\n".join(lines)
+
+
+def register() -> DevTool:
+    return UrlTool()