wisal-cli 0.1.0__py3-none-any.whl

wisal/arabic_utils.py

@@ -0,0 +1,58 @@
+"""
+Helper utilities for handling Arabic-specific text quirks in data.
+"""
+
+import re
+
+# Arabic-Indic digit to Latin digit mapping
+ARABIC_INDIC_DIGITS = "٠١٢٣٤٥٦٧٨٩"
+LATIN_DIGITS = "0123456789"
+_DIGIT_TRANSLATION = str.maketrans(ARABIC_INDIC_DIGITS, LATIN_DIGITS)
+
+_ARABIC_DIGIT_RE = re.compile(f"[{ARABIC_INDIC_DIGITS}]")
+_LATIN_DIGIT_RE = re.compile(r"[0-9]")
+
+
+def contains_arabic_indic_digits(text: str) -> bool:
+    """Return True if the text contains Arabic-Indic digits."""
+    return bool(_ARABIC_DIGIT_RE.search(text))
+
+
+def has_mixed_digits(text: str) -> bool:
+    """Return True if the text mixes Arabic-Indic and Latin digits."""
+    return bool(_ARABIC_DIGIT_RE.search(text)) and bool(_LATIN_DIGIT_RE.search(text))
+
+
+def normalize_digits(text: str) -> str:
+    """Convert all Arabic-Indic digits in the text to Latin digits."""
+    if not isinstance(text, str):
+        return text
+    return text.translate(_DIGIT_TRANSLATION)
+
+
+def likely_encoding_issue(raw_bytes: bytes) -> str | None:
+    """
+    Try to detect whether the file uses a common non-UTF-8 encoding for
+    Arabic text (such as Windows-1256), returning the likely encoding name,
+    or None if the bytes are valid UTF-8.
+    """
+    try:
+        raw_bytes.decode("utf-8")
+        return None
+    except UnicodeDecodeError:
+        pass
+
+    for encoding in ("windows-1256", "iso-8859-6", "cp720"):
+        try:
+            raw_bytes.decode(encoding)
+            return encoding
+        except UnicodeDecodeError:
+            continue
+    return None
+
+
+def detect_column_digit_issues(values: list[str]) -> bool:
+    """Check a single column's values across rows for mixed digit systems."""
+    joined_has_arabic = any(contains_arabic_indic_digits(v) for v in values if isinstance(v, str))
+    joined_has_latin = any(_LATIN_DIGIT_RE.search(v) for v in values if isinstance(v, str))
+    return joined_has_arabic and joined_has_latin

wisal/cli.py

@@ -0,0 +1,148 @@
+"""
+Command-line interface for the Wisal tool.
+
+Usage:
+    wisal convert input.json output.csv
+    wisal convert data.csv data.yaml --flatten
+    wisal convert data.json out.csv --dry-run --lang ar
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from wisal.arabic_utils import normalize_digits
+from wisal.errors import WisalError
+from wisal.formats import format_from_extension, load_data, write_data, write_stdout
+from wisal.messages import Lang, detect_language, t
+from wisal.validate import validate_rows
+
+__version__ = "0.1.0"
+
+
+def _apply_digit_normalization(data):
+    """Recursively apply digit normalization to every string in the structure."""
+    if isinstance(data, dict):
+        return {k: _apply_digit_normalization(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [_apply_digit_normalization(v) for v in data]
+    if isinstance(data, str):
+        return normalize_digits(data)
+    return data
+
+
+def build_parser() -> argparse.ArgumentParser:
+    lang_parent = argparse.ArgumentParser(add_help=False)
+    lang_parent.add_argument(
+        "--lang",
+        choices=["ar", "en"],
+        default=None,
+        help="Message language (ar/en). Default: auto-detect from system locale.",
+    )
+
+    parser = argparse.ArgumentParser(
+        prog="wisal",
+        description=(
+            "Wisal — a bilingual (Arabic/English) data conversion tool for JSON, CSV, and YAML."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        parents=[lang_parent],
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"wisal {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    convert = subparsers.add_parser(
+        "convert",
+        help="Convert a file from one format to another",
+        parents=[lang_parent],
+    )
+    convert.add_argument("input", help="Input file")
+    convert.add_argument("output", help="Output file")
+    convert.add_argument(
+        "--flatten",
+        action="store_true",
+        help="Flatten nested fields into columns (for CSV output)",
+    )
+    convert.add_argument(
+        "--normalize-digits",
+        action="store_true",
+        help="Normalize Arabic-Indic digits (٠-٩) to Latin digits",
+    )
+    convert.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview output without writing a file",
+    )
+    convert.add_argument(
+        "--no-validate",
+        action="store_true",
+        help="Skip data quality checks",
+    )
+    convert.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress warnings, show only errors",
+    )
+
+    return parser
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.lang:
+        os.environ["WISAL_LANG"] = args.lang
+    lang = Lang(args.lang) if args.lang else detect_language()
+
+    def warn(message: str) -> None:
+        if not getattr(args, "quiet", False):
+            print(f"⚠ {message}", file=sys.stderr)
+
+    if args.command == "convert":
+        input_path = Path(args.input)
+        output_path = Path(args.output)
+
+        try:
+            data = load_data(input_path, warn=warn)
+
+            if args.normalize_digits:
+                data = _apply_digit_normalization(data)
+
+            if not args.no_validate:
+                rows = data if isinstance(data, list) else [data]
+                validate_rows(rows, warn=warn)
+
+            if args.dry_run:
+                out_fmt = format_from_extension(output_path)
+                write_stdout(data, out_fmt, flatten=args.flatten, warn=warn)
+                print(t("dry_run_notice", lang=lang), file=sys.stderr)
+            else:
+                write_data(data, output_path, flatten=args.flatten, warn=warn)
+                row_count = len(data) if isinstance(data, list) else 1
+                print(
+                    t(
+                        "conversion_success",
+                        lang=lang,
+                        source=str(input_path),
+                        target=str(output_path),
+                        rows=row_count,
+                    )
+                )
+        except WisalError as e:
+            print(f"✗ {e}", file=sys.stderr)
+            return 1
+
+    return 0
+
+
+def main() -> None:
+    sys.exit(run())
+
+
+if __name__ == "__main__":
+    main()

wisal/errors.py

@@ -0,0 +1,6 @@
+"""Custom Wisal exceptions."""
+
+
+class WisalError(Exception):
+    """An expected error to show the user as a clear message, without a full traceback."""
+    pass

wisal/formats.py

@@ -0,0 +1,156 @@
+"""
+Reading and writing supported data formats: JSON, CSV, YAML.
+"""
+
+import csv
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from wisal.arabic_utils import likely_encoding_issue
+from wisal.errors import WisalError
+from wisal.messages import t
+
+SUPPORTED_FORMATS = ("json", "csv", "yaml", "yml")
+
+
+def format_from_extension(path: Path) -> str:
+    ext = path.suffix.lstrip(".").lower()
+    if ext == "yml":
+        ext = "yaml"
+    if ext not in SUPPORTED_FORMATS:
+        raise WisalError(t("unsupported_format", ext=ext or "(none)"))
+    return ext
+
+
+def read_file_bytes(path: Path) -> bytes:
+    if not path.exists():
+        raise WisalError(t("file_not_found", path=str(path)))
+    raw = path.read_bytes()
+    if len(raw) == 0:
+        raise WisalError(t("empty_input", path=str(path)))
+    return raw
+
+
+def load_data(path: Path, warn) -> Any:
+    """
+    Load data from a file based on its extension, checking encoding along the way.
+    """
+    fmt = format_from_extension(path)
+    raw = read_file_bytes(path)
+
+    detected_encoding = likely_encoding_issue(raw)
+    if detected_encoding:
+        warn(t("encoding_mismatch_warning", detected=detected_encoding))
+        text = raw.decode(detected_encoding, errors="replace")
+    else:
+        text = raw.decode("utf-8")
+
+    if fmt == "json":
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError as e:
+            raise WisalError(
+                t("invalid_json", line=e.lineno, column=e.colno, detail=e.msg)
+            ) from e
+
+    if fmt == "yaml":
+        try:
+            return yaml.safe_load(text)
+        except yaml.YAMLError as e:
+            raise WisalError(str(e)) from e
+
+    if fmt == "csv":
+        reader = csv.DictReader(text.splitlines())
+        return list(reader)
+
+    raise WisalError(t("unsupported_format", ext=fmt))
+
+
+def _flatten_dict(d: dict, parent_key: str = "", sep: str = ".") -> dict:
+    items = {}
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else str(k)
+        if isinstance(v, dict):
+            items.update(_flatten_dict(v, new_key, sep=sep))
+        else:
+            items[new_key] = v
+    return items
+
+
+def _rows_from_data(data: Any, flatten: bool, warn) -> list[dict]:
+    """Normalize any data structure (list or object) into a list of CSV-ready rows."""
+    if isinstance(data, dict):
+        data = [data]
+    if not isinstance(data, list):
+        raise WisalError(t("unsupported_format", ext="(structure)"))
+
+    rows = []
+    for row in data:
+        if not isinstance(row, dict):
+            rows.append({"value": row})
+            continue
+        new_row = {}
+        for key, value in row.items():
+            if isinstance(value, (dict, list)):
+                if flatten and isinstance(value, dict):
+                    new_row.update(_flatten_dict({key: value}))
+                else:
+                    warn(t("nested_structure_warning", field=key))
+                    new_row[key] = json.dumps(value, ensure_ascii=False)
+            else:
+                new_row[key] = value
+        rows.append(new_row)
+    return rows
+
+
+def write_data(data: Any, path: Path, flatten: bool, warn) -> None:
+    """
+    Write data to a file based on its extension.
+    """
+    fmt = format_from_extension(path)
+
+    if fmt == "json":
+        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        return
+
+    if fmt == "yaml":
+        path.write_text(
+            yaml.dump(data, allow_unicode=True, sort_keys=False), encoding="utf-8"
+        )
+        return
+
+    if fmt == "csv":
+        rows = _rows_from_data(data, flatten=flatten, warn=warn)
+        if not rows:
+            path.write_text("", encoding="utf-8")
+            return
+        fieldnames = list(dict.fromkeys(k for row in rows for k in row.keys()))
+        with path.open("w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            for row in rows:
+                writer.writerow(row)
+        return
+
+    raise WisalError(t("unsupported_format", ext=fmt))
+
+
+def write_stdout(data: Any, fmt: str, flatten: bool, warn) -> None:
+    """Write the output to stdout (for dry-run preview mode)."""
+    if fmt == "json":
+        sys.stdout.write(json.dumps(data, ensure_ascii=False, indent=2) + "\n")
+    elif fmt == "yaml":
+        sys.stdout.write(yaml.dump(data, allow_unicode=True, sort_keys=False))
+    elif fmt == "csv":
+        rows = _rows_from_data(data, flatten=flatten, warn=warn)
+        if not rows:
+            return
+        fieldnames = list(dict.fromkeys(k for row in rows for k in row.keys()))
+        writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow(row)

wisal/messages.py

@@ -0,0 +1,111 @@
+"""
+Bilingual (Arabic/English) message system for the Wisal CLI tool.
+
+Language is auto-detected from the LANG environment variable, or forced via --lang.
+"""
+
+import os
+from enum import Enum
+
+
+class Lang(str, Enum):
+    AR = "ar"
+    EN = "en"
+
+
+def detect_language() -> Lang:
+    """Detect the appropriate language from the system environment. Defaults to English."""
+    env_lang = os.environ.get("WISAL_LANG", "").lower()
+    if env_lang in ("ar", "arabic"):
+        return Lang.AR
+    if env_lang in ("en", "english"):
+        return Lang.EN
+
+    system_lang = os.environ.get("LANG", "") + os.environ.get("LC_ALL", "")
+    if "ar" in system_lang.lower():
+        return Lang.AR
+    return Lang.EN
+
+
+# كل رسالة لها مفتاح، وقيمة لكل لغة.
+# Each message has a key, and a value per language.
+MESSAGES = {
+    "file_not_found": {
+        Lang.AR: "خطأ: الملف '{path}' غير موجود. تأكد من المسار وحاول مرة أخرى.",
+        Lang.EN: "Error: File '{path}' was not found. Check the path and try again.",
+    },
+    "unsupported_format": {
+        Lang.AR: "خطأ: الصيغة '{ext}' غير مدعومة. الصيغ المدعومة: json, csv, yaml.",
+        Lang.EN: "Error: Format '{ext}' is not supported. Supported formats: json, csv, yaml.",
+    },
+    "key_missing_in_row": {
+        Lang.AR: "تحذير: الحقل '{field}' غير موجود في السطر {line}. تم استخدام قيمة فارغة بدلاً منه.",
+        Lang.EN: "Warning: Field '{field}' is missing in row {line}. An empty value was used instead.",
+    },
+    "encoding_detected": {
+        Lang.AR: "تم اكتشاف ترميز النص التالي: {encoding}. سيتم استخدامه لقراءة الملف.",
+        Lang.EN: "Detected text encoding: {encoding}. It will be used to read the file.",
+    },
+    "encoding_mismatch_warning": {
+        Lang.AR: "تحذير: الملف يبدو أنه بترميز '{detected}' وليس UTF-8. "
+        "قد يظهر النص العربي بشكل غير صحيح إذا لم تتم معالجته.",
+        Lang.EN: "Warning: The file appears to be encoded as '{detected}', not UTF-8. "
+        "Arabic text may display incorrectly if this is not handled.",
+    },
+    "mixed_digits_warning": {
+        Lang.AR: "تحذير: تم العثور على أرقام عربية-هندية (٠-٩) مختلطة مع أرقام لاتينية في العمود '{column}'. "
+        "استخدم --normalize-digits لتوحيدها.",
+        Lang.EN: "Warning: Arabic-Indic digits (٠-٩) found mixed with Latin digits in column '{column}'. "
+        "Use --normalize-digits to unify them.",
+    },
+    "conversion_success": {
+        Lang.AR: "تم تحويل '{source}' إلى '{target}' بنجاح. ({rows} سطر/عنصر)",
+        Lang.EN: "Successfully converted '{source}' to '{target}'. ({rows} rows/items)",
+    },
+    "invalid_json": {
+        Lang.AR: "خطأ في تحليل JSON بالقرب من السطر {line}، العمود {column}: {detail}",
+        Lang.EN: "JSON parsing error near line {line}, column {column}: {detail}",
+    },
+    "nested_structure_warning": {
+        Lang.AR: "تحذير: الحقل '{field}' يحتوي على بنية متداخلة ولا يمكن تمثيله مباشرة في CSV. "
+        "تم تحويله إلى نص JSON مضمّن. استخدم --flatten لتفكيك البنية إلى أعمدة.",
+        Lang.EN: "Warning: Field '{field}' contains a nested structure that cannot be represented "
+        "directly in CSV. It was embedded as a JSON string. Use --flatten to expand it into columns.",
+    },
+    "empty_input": {
+        Lang.AR: "خطأ: الملف المدخل '{path}' فارغ. لا يوجد شيء لتحويله.",
+        Lang.EN: "Error: Input file '{path}' is empty. Nothing to convert.",
+    },
+    "output_written": {
+        Lang.AR: "تم حفظ الناتج في: {path}",
+        Lang.EN: "Output saved to: {path}",
+    },
+    "dry_run_notice": {
+        Lang.AR: "وضع المعاينة فقط (dry-run): لم يتم حفظ أي ملف.",
+        Lang.EN: "Dry-run mode: no file was written.",
+    },
+    "validation_type_mismatch": {
+        Lang.AR: "تحذير: العمود '{column}' يحتوي على أنواع بيانات مختلطة "
+        "(مثال: أرقام ونصوص معاً) في الأسطر: {lines}.",
+        Lang.EN: "Warning: Column '{column}' has mixed data types "
+        "(e.g. numbers and text together) in rows: {lines}.",
+    },
+    "diff_summary": {
+        Lang.AR: "ملخص المقارنة: {added} حقل مُضاف، {removed} حقل محذوف، {changed} حقل مُغيّر.",
+        Lang.EN: "Diff summary: {added} field(s) added, {removed} field(s) removed, {changed} field(s) changed.",
+    },
+}
+
+
+def t(key: str, lang: Lang | None = None, **kwargs) -> str:
+    """
+    ترجمة مفتاح رسالة إلى نص باللغة المطلوبة، مع تعبئة المتغيرات.
+    Translate a message key into text in the requested language, filling in variables.
+    """
+    if lang is None:
+        lang = detect_language()
+    template = MESSAGES.get(key, {}).get(lang)
+    if template is None:
+        # احتياط: استخدم الإنجليزية إذا لم توجد الرسالة باللغة المطلوبة
+        template = MESSAGES.get(key, {}).get(Lang.EN, key)
+    return template.format(**kwargs)

wisal/validate.py

@@ -0,0 +1,59 @@
+"""
+Data quality checks prior to conversion: mixed types, mixed digits, missing fields.
+"""
+
+from typing import Any
+
+from wisal.arabic_utils import detect_column_digit_issues
+from wisal.messages import t
+
+
+def _python_type_name(value: Any) -> str:
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "bool"
+    if isinstance(value, (int, float)):
+        return "number"
+    return "text"
+
+
+def validate_rows(rows: list[dict], warn) -> None:
+    """
+    Run all quality checks on a list of rows (already normalized to dicts)
+    and emit warnings through the provided warn function.
+    """
+    if not rows:
+        return
+
+    columns: dict[str, list] = {}
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        for key, value in row.items():
+            columns.setdefault(key, []).append(value)
+
+    for column, values in columns.items():
+        # Check for mixed types
+        types_seen = {}
+        for idx, value in enumerate(values):
+            type_name = _python_type_name(value)
+            if type_name in ("null",):
+                continue
+            types_seen.setdefault(type_name, []).append(idx + 1)
+
+        non_null_types = [k for k in types_seen if k != "null"]
+        if len(non_null_types) > 1:
+            all_lines = sorted({ln for lns in types_seen.values() for ln in lns})
+            warn(
+                t(
+                    "validation_type_mismatch",
+                    column=column,
+                    lines=", ".join(str(x) for x in all_lines[:10]),
+                )
+            )
+
+        # Check for mixed Arabic-Indic/Latin digits
+        str_values = [v for v in values if isinstance(v, str)]
+        if str_values and detect_column_digit_issues(str_values):
+            warn(t("mixed_digits_warning", column=column))

wisal_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: wisal-cli
+Version: 0.1.0
+Summary: Bilingual (Arabic/English) CLI tool to convert between JSON, CSV, and YAML
+Author: Wisal Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/amgdsaleh66/wisal
+Project-URL: Issues, https://github.com/amgdsaleh66/wisal/issues
+Keywords: cli,json,csv,yaml,convert,arabic,bilingual,i18n
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: Arabic
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Localization
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# Wisal (وصال)
+
+**A bilingual (Arabic/English) CLI tool to convert data between JSON, CSV, and YAML.**
+
+## Why Wisal?
+
+Most data conversion tools (jc, Miller, dasel...) are excellent but entirely English: error messages, warnings, even documentation. This creates a real barrier for thousands of Arabic-speaking developers, especially when debugging complex data.
+
+Wisal is a small, focused tool that solves exactly this problem:
+
+- 🌐 Every message (error, warning, help) is available in Arabic and English, auto-detected from the system locale (defaults to English)
+- 🔢 Detects and handles Arabic-Indic digits (٠-٩) mixed with Latin digits in the same data
+- 🔤 Detects common encoding issues (Windows-1256 vs UTF-8) that corrupt Arabic text
+- ✅ Validates data quality before converting (mixed types, nested fields) instead of silently failing
+- 📦 No bloat: one tool, one command, predictable behavior
+
+## Installation
+
+```bash
+pip install wisal-cli
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/amgdsaleh66/wisal.git
+cd wisal
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Simple conversion
+wisal convert data.json data.csv
+
+# Force Arabic messages
+wisal convert data.json data.csv --lang ar
+
+# Flatten nested fields when converting to CSV
+wisal convert data.json data.csv --flatten
+
+# Normalize Arabic-Indic digits to Latin
+wisal convert data.json data.csv --normalize-digits
+
+# Preview output without saving
+wisal convert data.json data.csv --dry-run
+```
+
+Run `wisal --help` or `wisal convert --help` for the full list of options.
+
+### Example
+
+**input.json:**
+```json
+[
+  {"name": "Ahmad", "age": "٣٠", "city": "Riyadh"},
+  {"name": "Sara", "age": 25, "city": "Dubai"}
+]
+```
+
+```bash
+wisal convert input.json output.csv --normalize-digits
+```
+
+```
+⚠ Warning: Column 'age' has mixed data types (e.g. numbers and text together) in rows: 1, 2.
+Successfully converted 'input.json' to 'output.csv'. (2 rows/items)
+```
+
+## Supported Formats
+
+| From \ To | JSON | CSV | YAML |
+|-----------|------|-----|------|
+| JSON      | —    | ✅  | ✅   |
+| CSV       | ✅   | —   | ✅   |
+| YAML      | ✅   | ✅  | —    |
+
+## Contributing
+
+Contributions welcome! Open an issue or pull request.
+
+```bash
+pip install -e ".[dev]"
+pytest tests/
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## License
+
+MIT

wisal_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+wisal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wisal/arabic_utils.py,sha256=_PL6umZ-i_AHnHn7_pHrKdjeKS7oYJl1O02UQ-9v45U,1919
+wisal/cli.py,sha256=1U-c4zME1Nt2sZPF0OYMR9uTVhSDBX0SGxesLIkMngc,4407
+wisal/errors.py,sha256=gCAzesp9CHWuRy_J7ppLGvrCi2jADxCDr0vvqpuoPso,162
+wisal/formats.py,sha256=qnD3JexvDg28UI7fFoTNuQeYybZ92OChae8HIrTMEgI,4865
+wisal/messages.py,sha256=MdbTBoK7iO1voks7fHsew7Vg6DOdVhyc8Qd1xeGFizA,5480
+wisal/validate.py,sha256=SFJ18mmgJwvY4d-QUPiufa9tgPNsQ8PATGAauoA6gf4,1838
+wisal_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Sz3Wb_sXW4NFFX8-xUvuCAvhLM5SDBU33rxL_LjtoNo,1075
+wisal_cli-0.1.0.dist-info/METADATA,sha256=Gp4xoMbcQXIjMnulyjF7Yj1dBwOtFdBnpx9zneTHLYE,3449
+wisal_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+wisal_cli-0.1.0.dist-info/entry_points.txt,sha256=l_MMVZQs0p_91XQO5N4Z1hIBWXSOr6y7gyCvXu_tAko,41
+wisal_cli-0.1.0.dist-info/top_level.txt,sha256=GBW7UDmzQT_SdSnxPPzsvt6qpmAV8BSSFBN_q8QGbH4,6
+wisal_cli-0.1.0.dist-info/RECORD,,

wisal_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wisal_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wisal = wisal.cli:main

wisal_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wisal Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wisal_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wisal