persian-devkit 1.0.0__py3-none-any.whl

persian_devkit/commands/password_cmd.py

@@ -0,0 +1,55 @@
+"""دستور pdev password — تولید و سنجش رمز عبور."""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from persian_devkit.utils.crypto_utils import (
+    generate_password,
+    password_strength,
+)
+
+app = typer.Typer(help="تولید و سنجش رمز عبور.", no_args_is_help=True)
+console = Console()
+
+
+@app.command("new")
+def new_cmd(
+    length: int = typer.Option(16, "--length", "-l", min=4, max=256, help="طول رمز."),
+    no_symbols: bool = typer.Option(False, "--no-symbols", help="بدون نمادها."),
+    no_upper: bool = typer.Option(False, "--no-upper", help="بدون حروف بزرگ."),
+    no_digits: bool = typer.Option(False, "--no-digits", help="بدون ارقام."),
+    count: int = typer.Option(1, "--count", "-c", min=1, max=100, help="تعداد."),
+) -> None:
+    """تولید رمز عبور امن."""
+    try:
+        for _ in range(count):
+            console.print(
+                generate_password(
+                    length=length,
+                    use_upper=not no_upper,
+                    use_digits=not no_digits,
+                    use_symbols=not no_symbols,
+                )
+            )
+    except ValueError as e:
+        console.print(f"[red]✗ خطا:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("check")
+def check_cmd(
+    password: str = typer.Argument(..., help="رمز برای سنجش قدرت."),
+) -> None:
+    """سنجش قدرت رمز عبور."""
+    result = password_strength(password)
+
+    color = "red" if result["score"] < 40 else "yellow" if result["score"] < 70 else "green"
+    table = Table(title=" قدرت رمز", title_style="bold cyan")
+    table.add_column("شاخص", style="bold")
+    table.add_column("مقدار")
+    table.add_row("امتیاز", f"[{color}]{result['score']}/100[/{color}]")
+    table.add_row("برچسب", f"[{color}]{result['label']}[/{color}]")
+    table.add_row("آنتروپی", f"{result['entropy']} بیت")
+    console.print(table)

persian_devkit/commands/qrcode_cmd.py

@@ -0,0 +1,46 @@
+"""دستور pdev qrcode — تولید QR Code از متن."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from persian_devkit.utils.qrcode_utils import qr_to_ascii, qr_to_image
+
+console = Console()
+
+
+def qrcode_command(
+    text: str = typer.Argument(..., help="متن یا URL برای رمزگذاری."),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="ذخیره به فایل تصویری (پسوند از نام)."
+    ),
+    error: str = typer.Option(
+        "M", "--error", "-e", help="سطح تصحیح خطا: L, M, Q, H."
+    ),
+    box_size: int = typer.Option(
+        10, "--box-size", "-b", min=1, max=50, help="اندازهٔ هر بلوک (فقط برای فایل)."
+    ),
+    border: int = typer.Option(
+        2, "--border", min=0, max=10, help="حاشیه (فقط برای فایل)."
+    ),
+) -> None:
+    """تولید QR Code از متن (فارسی یا انگلیسی)."""
+    if output is not None:
+        try:
+            qr_to_image(text, output, error=error, box_size=box_size, border=border)
+        except Exception as e:
+            console.print(f"[red]✗ خطا:[/red] {e}")
+            raise typer.Exit(1)
+        console.print(f"[green]✓ ذخیره شد:[/green] {output}")
+        return
+
+    try:
+        art = qr_to_ascii(text, error=error, border=1)
+    except Exception as e:
+        console.print(f"[red]✗ خطا:[/red] {e}")
+        raise typer.Exit(1)
+
+    console.print(art, highlight=False, markup=False, soft_wrap=True)

persian_devkit/commands/random_cmd.py

@@ -0,0 +1,110 @@
+"""دستور pdev random — تولید مقادیر تصادفی."""
+from __future__ import annotations
+
+import secrets
+import string
+
+import typer
+from rich.console import Console
+
+from persian_devkit.utils.crypto_utils import nanoid
+
+app = typer.Typer(help="تولید مقادیر تصادفی.", no_args_is_help=True)
+console = Console()
+
+
+@app.command("int")
+def int_cmd(
+    low: int = typer.Argument(0, help="کران پایین (شامل)."),
+    high: int = typer.Argument(100, help="کران بالا (شامل)."),
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد."),
+) -> None:
+    """تولید عدد صحیح تصادفی در بازه."""
+    if low > high:
+        console.print("[red]✗ خطا:[/red] کران پایین بزرگ‌تر از بالا است.")
+        raise typer.Exit(1)
+    for _ in range(count):
+        console.print(secrets.randbelow(high - low + 1) + low)
+
+
+@app.command("str")
+def str_cmd(
+    length: int = typer.Option(16, "--length", "-l", min=1, help="طول."),
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد."),
+    alphabet: str = typer.Option(
+        "full",
+        "--alphabet",
+        "-a",
+        help="مجموعهٔ کاراکتر: letters, digits, hex, full.",
+    ),
+) -> None:
+    """تولید رشتهٔ تصادفی."""
+    pools = {
+        "letters": string.ascii_letters,
+        "digits": string.digits,
+        "hex": "0123456789abcdef",
+        "full": string.ascii_letters + string.digits,
+    }
+    if alphabet not in pools:
+        console.print(f"[red]✗ خطا:[/red] مجموعهٔ ناشناخته: {alphabet}")
+        raise typer.Exit(1)
+    pool = pools[alphabet]
+    for _ in range(count):
+        console.print("".join(secrets.choice(pool) for _ in range(length)))
+
+
+@app.command("choice")
+def choice_cmd(
+    items: list[str] = typer.Argument(..., help="گزینه‌ها برای انتخاب."),
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد انتخاب."),
+    replace: bool = typer.Option(
+        False, "--replace", "-r", help="انتخاب با جای‌گذاری (تکرار مجاز)."
+    ),
+) -> None:
+    """انتخاب تصادفی از میان گزینه‌ها."""
+    if count > len(items) and not replace:
+        console.print(
+            "[red]✗ خطا:[/red] تعداد بیشتر از گزینه‌هاست. از --replace استفاده کن."
+        )
+        raise typer.Exit(1)
+    if replace:
+        for _ in range(count):
+            console.print(secrets.choice(items))
+    else:
+        # Fisher-Yates با secrets
+        pool = list(items)
+        for i in range(count):
+            j = i + secrets.randbelow(len(pool) - i)
+            pool[i], pool[j] = pool[j], pool[i]
+            console.print(pool[i])
+
+
+@app.command("coin")
+def coin_cmd(
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد پرتاب."),
+    heads_label: str = typer.Option("شیر", "--heads"),
+    tails_label: str = typer.Option("خط", "--tails"),
+) -> None:
+    """پرتاب سکه."""
+    for _ in range(count):
+        console.print(heads_label if secrets.randbelow(2) == 0 else tails_label)
+
+
+@app.command("dice")
+def dice_cmd(
+    sides: int = typer.Option(6, "--sides", "-s", min=2, help="تعداد وجه."),
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد تاس."),
+) -> None:
+    """پرتاب تاس."""
+    for _ in range(count):
+        console.print(secrets.randbelow(sides) + 1)
+
+
+@app.command("nanoid")
+def nanoid_cmd(
+    length: int = typer.Option(21, "--length", "-l", min=1, help="طول."),
+    count: int = typer.Option(1, "--count", "-c", min=1, help="تعداد."),
+) -> None:
+    """تولید Nano ID."""
+    for _ in range(count):
+        console.print(nanoid(length))

persian_devkit/commands/scaffold_cmd.py

@@ -0,0 +1,155 @@
+"""دستور pdev scaffold — ساخت ساختار پروژه از قالب."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+# قالب‌های پروژه: {filepath: content}
+_SCAFFOLDS: dict[str, dict[str, str]] = {
+    "python": {
+        "README.md": "# {name}\n\nتوضیح پروژه...\n",
+        "pyproject.toml": """[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{name}"
+version = "0.1.0"
+description = ""
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[project.scripts]
+{name} = "{name}.main:main"
+""",
+        "requirements.txt": "",
+        "src/{name}/__init__.py": '"""پکیج {name}."""\n\n__version__ = "0.1.0"\n',
+        "src/{name}/main.py": '''"""نقطهٔ ورود {name}."""
+
+
+def main() -> None:
+    """تابع اصلی."""
+    print("سلام از {name}!")
+
+
+if __name__ == "__main__":
+    main()
+''',
+        "tests/__init__.py": "",
+        "tests/test_main.py": '''"""تست‌های {name}."""
+from {name}.main import main
+
+
+def test_main_runs(capsys):
+    main()
+    captured = capsys.readouterr()
+    assert "{name}" in captured.out
+''',
+        ".gitignore": "__pycache__/\n*.pyc\n.venv/\nvenv/\ndist/\nbuild/\n*.egg-info/\n",
+    },
+    "node": {
+        "README.md": "# {name}\n\nتوضیح پروژه...\n",
+        "package.json": """{{
+  "name": "{name}",
+  "version": "0.1.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {{
+    "start": "node src/index.js",
+    "test": "echo \\"Error: no test specified\\" && exit 1"
+  }},
+  "keywords": [],
+  "author": "",
+  "license": "MIT"
+}}
+""",
+        "src/index.js": "console.log('سلام از {name}!');\n",
+        ".gitignore": "node_modules/\ndist/\n.env\n.env.local\n",
+    },
+    "minimal": {
+        "README.md": "# {name}\n",
+        ".gitignore": "__pycache__/\n.venv/\n.env\n",
+    },
+}
+
+
+def _create_files(root: Path, name: str, scaffold: dict[str, str]) -> list[Path]:
+    """فایل‌های قالب را می‌سازد و لیست مسیرها را برمی‌گرداند."""
+    created: list[Path] = []
+    for rel, content in scaffold.items():
+        path = root / rel.format(name=name)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        rendered = content.format(name=name)
+        path.write_text(rendered, encoding="utf-8")
+        created.append(path)
+    return created
+
+
+def scaffold_command(
+    kind: Optional[str] = typer.Argument(
+        None, help="نوع قالب: python، node، minimal."
+    ),
+    name: Optional[str] = typer.Argument(None, help="نام پروژه."),
+    target: Path = typer.Option(
+        Path("."), "--target", "-t", help="پوشهٔ مقصد (پیش‌فرض: جاری)."
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="اجرای اجباری روی پوشه‌های موجود."
+    ),
+    list_templates: bool = typer.Option(
+        False, "--list", "-l", help="نمایش قالب‌های موجود."
+    ),
+) -> None:
+    """ساخت ساختار پروژه از قالب.
+
+    مثال:
+      pdev scaffold python myproject
+      pdev scaffold node myapp --target ./projects
+      pdev scaffold --list
+    """
+    # حالت --list: نمایش قالب‌ها و خروج
+    if list_templates:
+        console.print("قالب‌های پروژه:")
+        for tname in _SCAFFOLDS:
+            console.print(f"  • {tname}")
+        return
+
+    if kind is None or name is None:
+        console.print("[red]✗ خطا:[/red] نوع قالب و نام پروژه الزامی است.")
+        console.print("برای دیدن قالب‌ها: [bold]pdev scaffold --list[/bold]")
+        raise typer.Exit(1)
+
+    key = kind.lower()
+    if key not in _SCAFFOLDS:
+        console.print(
+            f"[red]✗ خطا:[/red] قالب ناشناخته: {kind}. "
+            f"موجود: {', '.join(_SCAFFOLDS.keys())}"
+        )
+        raise typer.Exit(1)
+
+    if not name or "/" in name or "\\" in name:
+        console.print(f"[red]✗ خطا:[/red] نام پروژه نامعتبر: {name}")
+        raise typer.Exit(1)
+
+    root = target.resolve() / name
+    if root.exists() and not force:
+        console.print(
+            f"[red]✗ خطا:[/red] پوشهٔ مقصد وجود دارد: {root} (از --force استفاده کن)"
+        )
+        raise typer.Exit(1)
+
+    root.mkdir(parents=True, exist_ok=True)
+    created = _create_files(root, name, _SCAFFOLDS[key])
+
+    console.print(f"[green]✓ پروژه ساخته شد:[/green] {root}")
+    for p in created:
+        rel = p.relative_to(root)
+        console.print(f"  • {rel}")
+    console.print(f"\n[cyan]قدم بعدی:[/cyan] cd {root}")
+

persian_devkit/commands/template_cmd.py

@@ -0,0 +1,87 @@
+"""دستور pdev template — رندر قالب ساده با متغیر."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+# سینتکس: {{var}} یا {{ var }}
+_VAR_RE = re.compile(r"\{\{\s*([A-Za-z_][\w\.\-]*)\s*\}\}")
+
+
+def render_template(text: str, variables: dict[str, str]) -> str:
+    """جایگذاری متغیرها در قالب. متغیرهای تعریف‌نشده دست‌نخورده می‌مانند."""
+    def replacer(m: re.Match) -> str:
+        key = m.group(1)
+        return variables.get(key, m.group(0))
+
+    return _VAR_RE.sub(replacer, text)
+
+
+def find_variables(text: str) -> list[str]:
+    """لیست متغیرهای داخل قالب (بدون تکرار، به ترتیب ظهور)."""
+    seen: list[str] = []
+    for m in _VAR_RE.finditer(text):
+        key = m.group(1)
+        if key not in seen:
+            seen.append(key)
+    return seen
+
+
+def template_command(
+    file: Path = typer.Argument(..., help="مسیر فایل قالب."),
+    var: list[str] = typer.Option(
+        [], "--var", "-D", help="متغیر به شکل key=value (چند بار مجاز)."
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="ذخیره در فایل خروجی."
+    ),
+    show_vars: bool = typer.Option(
+        False, "--vars", "-V", help="فقط نمایش متغیرهای قالب (بدون رندر)."
+    ),
+) -> None:
+    """رندر یک قالب متنی با متغیرها.
+
+    مثال:
+      pdev template greet.txt -D name=علی -D city=تهران
+      pdev template config.tpl -D port=8080 -o config.yaml
+      pdev template greet.txt --vars
+    """
+    if not file.exists():
+        console.print(f"[red]✗ خطا:[/red] فایل یافت نشد: {file}")
+        raise typer.Exit(1)
+
+    text = file.read_text(encoding="utf-8")
+
+    # حالت --vars: فقط نمایش متغیرها
+    if show_vars:
+        found = find_variables(text)
+        if not found:
+            console.print("[yellow]⚠ هیچ متغیری یافت نشد.[/yellow]")
+            return
+        console.print(f"متغیرهای یافت‌شده ({len(found)}):")
+        for v in found:
+            console.print(f"  • {v}")
+        return
+
+    # تجزیهٔ متغیرهای داده‌شده
+    variables: dict[str, str] = {}
+    for item in var:
+        if "=" not in item:
+            console.print(f"[red]✗ خطا:[/red] فرمت نامعتبر: {item} (باید key=value)")
+            raise typer.Exit(1)
+        k, v = item.split("=", 1)
+        variables[k.strip()] = v
+
+    rendered = render_template(text, variables)
+
+    if output:
+        output.write_text(rendered, encoding="utf-8")
+        console.print(f"[green]✓ ذخیره شد:[/green] {output}")
+    else:
+        console.print(rendered, highlight=False, markup=False)

persian_devkit/commands/text_cmd.py

@@ -0,0 +1,157 @@
+"""دستور `pdev text` — پاک‌سازی و پردازش متن فارسی."""
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from persian_devkit.utils.text_utils import (
+    change_case,
+    diff_lines,
+    fix_halfspace,
+    normalize,
+    regex_test,
+    reverse_text,
+    text_stats,
+    to_slug,
+)
+
+app = typer.Typer(help="پاک‌سازی و پردازش متن فارسی.", no_args_is_help=True)
+console = Console()
+
+
+def _read_text(value: Optional[str]) -> str:
+    """اگر مقدار داده نشد، از stdin می‌خواند."""
+    if value is not None and value != "":
+        return value
+    try:
+        if not sys.stdin.isatty():
+            data = sys.stdin.read()
+            if data.strip():
+                return data.rstrip("\n")
+    except (AttributeError, OSError):
+        pass
+    console.print(
+        "[red]✗ خطا:[/red] متنی وارد نشده. یک آرگومان بده یا از stdin استفاده کن."
+    )
+    raise typer.Exit(1)
+
+
+@app.command("halfspace")
+def halfspace_cmd(
+    text: Optional[str] = typer.Argument(
+        None, help="متن ورودی (اگر ندهی، از stdin خوانده می‌شود)."
+    ),
+) -> None:
+    """اصلاح نیم‌فاصله در متن فارسی."""
+    console.print(fix_halfspace(_read_text(text)))
+
+
+@app.command("normalize")
+def normalize_cmd(
+    text: Optional[str] = typer.Argument(
+        None, help="متن ورودی (اگر ندهی، از stdin خوانده می‌شود)."
+    ),
+) -> None:
+    """یکسان‌سازی حروف (ی/ک عربی) و حذف فاصله‌های اضافه."""
+    console.print(normalize(_read_text(text)))
+
+
+@app.command("reverse")
+def reverse_cmd(
+    text: Optional[str] = typer.Argument(
+        None, help="متن ورودی (اگر ندهی، از stdin خوانده می‌شود)."
+    ),
+) -> None:
+    """معکوس‌سازی متن."""
+    console.print(reverse_text(_read_text(text)))
+
+
+@app.command("stats")
+def stats_cmd(
+    text: Optional[str] = typer.Argument(
+        None, help="متن ورودی (اگر ندهی، از stdin خوانده می‌شود)."
+    ),
+) -> None:
+    """نمایش آمار متن (کاراکتر، کلمه، خط، جمله)."""
+    stats = text_stats(_read_text(text))
+
+    table = Table(title=" آمار متن", title_style="bold cyan")
+    table.add_column("شاخص", style="bold")
+    table.add_column("مقدار", justify="right", style="green")
+    table.add_row("کاراکترها", str(stats["chars"]))
+    table.add_row("کاراکترهای غیرفاصله", str(stats["chars_no_space"]))
+    table.add_row("کلمات", str(stats["words"]))
+    table.add_row("خطوط", str(stats["lines"]))
+    table.add_row("جملات", str(stats["sentences"]))
+    console.print(table)
+
+@app.command("slug")
+def slug_cmd(
+    text: Optional[str] = typer.Argument(None, help="متن ورودی (یا از stdin)."),
+    separator: str = typer.Option("-", "--sep", "-s", help="جداکننده."),
+    max_length: int = typer.Option(
+        0, "--max-length", "-m", min=0, help="حداکثر طول (۰ = بدون محدودیت)."
+    ),
+) -> None:
+    """تبدیل متن به slug قابل استفاده در URL."""
+    console.print(to_slug(_read_text(text), separator=separator, max_length=max_length))
+
+
+@app.command("case")
+def case_cmd(
+    mode: str = typer.Argument(
+        ..., help="حالت: upper, lower, title, capitalize, swap."
+    ),
+    text: Optional[str] = typer.Argument(None, help="متن ورودی (یا از stdin)."),
+) -> None:
+    """تغییر حالت حروف متن."""
+    try:
+        console.print(change_case(_read_text(text), mode))
+    except ValueError as e:
+        console.print(f"[red]✗ خطا:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("diff")
+def diff_cmd(
+    a: str = typer.Argument(..., help="متن اول."),
+    b: str = typer.Argument(..., help="متن دوم."),
+) -> None:
+    """مقایسهٔ خطی دو متن (مانند diff)."""
+    lines = diff_lines(a, b)
+    if not lines:
+        console.print("[green]✓ دو متن یکسان هستند.[/green]")
+        return
+    for sign, line in lines:
+        if sign == "-":
+            console.print(f"[red]- {line}[/red]")
+        elif sign == "+":
+            console.print(f"[green]+ {line}[/green]")
+        else:
+            console.print(f"[dim]  {line}[/dim]")
+
+
+@app.command("regex")
+def regex_cmd(
+    pattern: str = typer.Argument(..., help="الگوی regex."),
+    text: Optional[str] = typer.Argument(None, help="متن ورودی (یا از stdin)."),
+) -> None:
+    """اجرای الگوی regex روی متن و نمایش نتایج."""
+    try:
+        result = regex_test(pattern, _read_text(text))
+    except ValueError as e:
+        console.print(f"[red]✗ خطا:[/red] {e}")
+        raise typer.Exit(1)
+
+    if result["is_match"]:
+        console.print("[green]✓ مطابقت یافت شد.[/green]")
+    else:
+        console.print("[yellow]⚠ مطابقتی یافت نشد.[/yellow]")
+
+    console.print(f"تعداد: [bold]{result['count']}[/bold]")
+    for m in result["matches"][:20]:
+        console.print(f"  • {m}")