alysis-code 0.13.0__py3-none-any.whl

alysis_code/assets/models.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Literal
+
+AssetKind = Literal["text", "image"]
+ComprehensionStatus = Literal["pending", "ready", "failed", "minimal"]
+ComprehensionSource = Literal[
+    "vision",
+    "vision_with_ocr",
+    "ocr_only",
+    "user_description",
+    "text_only",
+    "minimal",
+]
+
+
+class AssetError(RuntimeError):
+    pass
+
+
+class AssetAlreadyExistsError(AssetError):
+    def __init__(self, existing_id: str) -> None:
+        self.existing_id = existing_id
+        super().__init__(f"Asset content already exists as {existing_id}.")
+
+
+class AssetNotFoundError(AssetError):
+    pass
+
+
+class OcrError(AssetError):
+    pass
+
+
+@dataclass(frozen=True)
+class AssetRecord:
+    id: str
+    title: str
+    description: str
+    kind: AssetKind
+    mime: str
+    original_filename: str
+    size_bytes: int
+    sha256: str
+    stored_path: str
+    extracted_text_path: str | None
+    thumbnail_path: str | None
+    pinned: bool
+    added_at: str
+    added_by: dict[str, Any]
+    deleted_at: str | None
+    comprehension_status: ComprehensionStatus
+    comprehension_current_version: int | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> AssetRecord:
+        return cls(
+            id=str(payload.get("id") or "").strip(),
+            title=str(payload.get("title") or "").strip(),
+            description=str(payload.get("description") or ""),
+            kind=_literal_value(payload.get("kind"), {"text", "image"}, field_name="kind"),  # type: ignore[arg-type]
+            mime=str(payload.get("mime") or "").strip(),
+            original_filename=str(payload.get("original_filename") or ""),
+            size_bytes=int(payload.get("size_bytes") or 0),
+            sha256=str(payload.get("sha256") or "").strip(),
+            stored_path=str(payload.get("stored_path") or "").strip(),
+            extracted_text_path=_optional_string(payload.get("extracted_text_path")),
+            thumbnail_path=_optional_string(payload.get("thumbnail_path")),
+            pinned=bool(payload.get("pinned", False)),
+            added_at=str(payload.get("added_at") or "").strip(),
+            added_by=dict(payload.get("added_by") or {}),
+            deleted_at=_optional_string(payload.get("deleted_at")),
+            comprehension_status=_literal_value(
+                payload.get("comprehension_status"),
+                {"pending", "ready", "failed", "minimal"},
+                field_name="comprehension_status",
+            ),  # type: ignore[arg-type]
+            comprehension_current_version=_optional_int(
+                payload.get("comprehension_current_version")
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class ComprehensionData:
+    semantic_summary: str = ""
+    classification: dict[str, str] = field(default_factory=dict)
+    key_entities: list[dict[str, str]] = field(default_factory=list)
+    stated_facts: list[str] = field(default_factory=list)
+    stated_decisions: list[str] = field(default_factory=list)
+    stated_constraints: list[str] = field(default_factory=list)
+    actionable_signals: list[str] = field(default_factory=list)
+    open_questions: list[str] = field(default_factory=list)
+    relations_hint: str = ""
+    confidence: dict[str, float] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any] | None) -> ComprehensionData:
+        raw = payload if isinstance(payload, dict) else {}
+        return cls(
+            semantic_summary=str(raw.get("semantic_summary") or ""),
+            classification={
+                str(key): str(value) for key, value in dict(raw.get("classification") or {}).items()
+            },
+            key_entities=_dict_string_list(raw.get("key_entities")),
+            stated_facts=_string_list(raw.get("stated_facts")),
+            stated_decisions=_string_list(raw.get("stated_decisions")),
+            stated_constraints=_string_list(raw.get("stated_constraints")),
+            actionable_signals=_string_list(raw.get("actionable_signals")),
+            open_questions=_string_list(raw.get("open_questions")),
+            relations_hint=str(raw.get("relations_hint") or ""),
+            confidence=_float_dict(raw.get("confidence")),
+        )
+
+
+@dataclass(frozen=True)
+class ComprehensionRecord:
+    schema_version: int
+    version: int
+    asset_id: str
+    status: Literal["ready", "failed", "minimal"]
+    source: ComprehensionSource
+    model: str | None
+    role: str | None
+    ocr_engine: str | None
+    ocr_languages_used: list[str]
+    detected_language: str | None
+    language_confidence: float | None
+    confidence_modifier: float
+    tokens_used: dict[str, int]
+    elapsed_ms: int
+    generated_at: str
+    error: str | None
+    data: ComprehensionData
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = asdict(self)
+        payload["data"] = self.data.to_dict()
+        return payload
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> ComprehensionRecord:
+        return cls(
+            schema_version=int(payload.get("schema_version") or 1),
+            version=int(payload.get("version") or 0),
+            asset_id=str(payload.get("asset_id") or "").strip(),
+            status=_literal_value(
+                payload.get("status"),
+                {"ready", "failed", "minimal"},
+                field_name="status",
+            ),  # type: ignore[arg-type]
+            source=_literal_value(
+                payload.get("source"),
+                {
+                    "vision",
+                    "vision_with_ocr",
+                    "ocr_only",
+                    "user_description",
+                    "text_only",
+                    "minimal",
+                },
+                field_name="source",
+            ),  # type: ignore[arg-type]
+            model=_optional_string(payload.get("model")),
+            role=_optional_string(payload.get("role")),
+            ocr_engine=_optional_string(payload.get("ocr_engine")),
+            ocr_languages_used=_string_list(payload.get("ocr_languages_used")),
+            detected_language=_optional_string(payload.get("detected_language")),
+            language_confidence=_optional_float(payload.get("language_confidence")),
+            confidence_modifier=float(payload.get("confidence_modifier") or 0.0),
+            tokens_used=_int_dict(payload.get("tokens_used")),
+            elapsed_ms=int(payload.get("elapsed_ms") or 0),
+            generated_at=str(payload.get("generated_at") or "").strip(),
+            error=_optional_string(payload.get("error")),
+            data=ComprehensionData.from_dict(payload.get("data")),
+        )
+
+
+def _literal_value(value: Any, allowed: set[str], *, field_name: str) -> str:
+    text = str(value or "").strip()
+    if text not in allowed:
+        allowed_label = ", ".join(sorted(allowed))
+        raise AssetError(f"{field_name} must be one of: {allowed_label}")
+    return text
+
+
+def _optional_string(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _optional_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError) as e:
+        raise AssetError(f"Expected integer-compatible value: {value!r}") from e
+
+
+def _optional_float(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError) as e:
+        raise AssetError(f"Expected float-compatible value: {value!r}") from e
+
+
+def _string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [text for item in value if (text := str(item).strip())]
+
+
+def _dict_string_list(value: Any) -> list[dict[str, str]]:
+    if not isinstance(value, list):
+        return []
+    out: list[dict[str, str]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        cleaned = {
+            str(key).strip(): str(raw_value).strip()
+            for key, raw_value in item.items()
+            if str(key).strip() and str(raw_value).strip()
+        }
+        if cleaned:
+            out.append(cleaned)
+    return out
+
+
+def _float_dict(value: Any) -> dict[str, float]:
+    if not isinstance(value, dict):
+        return {}
+    out: dict[str, float] = {}
+    for key, raw_value in value.items():
+        try:
+            out[str(key)] = float(raw_value)
+        except (TypeError, ValueError):
+            continue
+    return out
+
+
+def _int_dict(value: Any) -> dict[str, int]:
+    if not isinstance(value, dict):
+        return {}
+    out: dict[str, int] = {}
+    for key, raw_value in value.items():
+        try:
+            out[str(key)] = int(raw_value)
+        except (TypeError, ValueError):
+            continue
+    return out

alysis_code/assets/ocr.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+from .models import OcrError
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ScriptDetection:
+    script: str
+    confidence: float
+
+
+@dataclass(frozen=True)
+class OcrResult:
+    text: str
+    languages_used: list[str]
+    confidence: float
+    engine_version: str
+    elapsed_ms: int
+
+
+class OcrProvider(Protocol):
+    name: str
+
+    def is_available(self) -> bool: ...
+
+    def installed_languages(self) -> list[str]: ...
+
+    def detect_script(self, image_path: Path) -> ScriptDetection | None: ...
+
+    def extract_text(
+        self,
+        image_path: Path,
+        *,
+        languages: list[str] | None = None,
+    ) -> OcrResult: ...
+
+
+class ScriptToLanguagesMapper:
+    def __init__(self, registry: dict[str, list[str]] | None = None) -> None:
+        self.registry = dict(_DEFAULT_SCRIPT_LANGUAGES)
+        if registry:
+            for script, languages in registry.items():
+                self.registry[str(script)] = [str(item) for item in languages if str(item).strip()]
+
+    def candidates(self, script: str, installed_languages: list[str]) -> list[str]:
+        installed = set(installed_languages)
+        candidates = self.registry.get(script, [])
+        return [language for language in candidates if language in installed]
+
+
+class TesseractOcrProvider:
+    name = "tesseract"
+
+    def __init__(
+        self,
+        *,
+        binary: str = "tesseract",
+        timeout_seconds: int = 30,
+        script_mapper: ScriptToLanguagesMapper | None = None,
+    ) -> None:
+        self.binary = binary
+        self.timeout_seconds = int(timeout_seconds)
+        self.script_mapper = script_mapper or ScriptToLanguagesMapper()
+
+    def is_available(self) -> bool:
+        return shutil.which(self.binary) is not None
+
+    def installed_languages(self) -> list[str]:
+        if not self.is_available():
+            return []
+        proc = self._run([self.binary, "--list-langs"])
+        languages: list[str] = []
+        for line in (proc.stdout or "").splitlines():
+            clean = line.strip()
+            clean_lower = clean.lower()
+            if (
+                not clean
+                or clean_lower == "list"
+                or clean_lower.startswith("list of available languages")
+            ):
+                continue
+            languages.append(clean)
+        return languages
+
+    def detect_script(self, image_path: Path) -> ScriptDetection | None:
+        if not self.is_available():
+            return None
+        proc = self._run(
+            [
+                self.binary,
+                str(image_path),
+                "-",
+                "-l",
+                "osd",
+                "--psm",
+                "0",
+            ]
+        )
+        text = "\n".join(part for part in (proc.stdout, proc.stderr) if part)
+        script = _parse_label(text, "Script")
+        if not script:
+            return None
+        confidence = _parse_float_label(text, "Script confidence") or 0.0
+        return ScriptDetection(script=script, confidence=confidence)
+
+    def extract_text(
+        self,
+        image_path: Path,
+        *,
+        languages: list[str] | None = None,
+    ) -> OcrResult:
+        if not self.is_available():
+            raise OcrError("Tesseract binary is not available.")
+        started = time.monotonic()
+        selected_languages = self._resolve_languages(image_path, languages)
+        language_arg = "+".join(selected_languages)
+        proc = self._run([self.binary, str(image_path), "-", "-l", language_arg])
+        confidence = self._extract_tsv_confidence(image_path, language_arg)
+        elapsed_ms = int((time.monotonic() - started) * 1000)
+        return OcrResult(
+            text=proc.stdout or "",
+            languages_used=selected_languages,
+            confidence=confidence,
+            engine_version=self._engine_version(),
+            elapsed_ms=elapsed_ms,
+        )
+
+    def _resolve_languages(self, image_path: Path, languages: list[str] | None) -> list[str]:
+        if languages:
+            explicit = [item for item in languages if item.strip()]
+            if explicit:
+                return explicit
+        try:
+            installed = self.installed_languages()
+        except OcrError as exc:
+            LOGGER.warning("Tesseract language listing failed: %s", exc)
+            installed = []
+        try:
+            detection = self.detect_script(image_path)
+        except OcrError as exc:
+            LOGGER.warning("Tesseract script detection failed: %s", exc)
+            detection = None
+        if detection is not None:
+            mapped = self.script_mapper.candidates(detection.script, installed)
+            if mapped:
+                return mapped
+        if installed:
+            return installed
+        return ["eng"]
+
+    def _extract_tsv_confidence(self, image_path: Path, language_arg: str) -> float:
+        try:
+            proc = self._run([self.binary, str(image_path), "-", "-l", language_arg, "tsv"])
+        except OcrError as exc:
+            LOGGER.warning("Tesseract TSV confidence extraction failed: %s", exc)
+            return 0.5
+        confidences: list[float] = []
+        for line in (proc.stdout or "").splitlines()[1:]:
+            columns = line.split("\t")
+            if len(columns) < 11:
+                continue
+            try:
+                confidence = float(columns[10])
+            except ValueError:
+                continue
+            if confidence >= 0:
+                confidences.append(confidence)
+        if not confidences:
+            return 0.5
+        return max(0.0, min(1.0, sum(confidences) / len(confidences) / 100.0))
+
+    def _engine_version(self) -> str:
+        try:
+            proc = self._run([self.binary, "--version"])
+        except OcrError:
+            return "tesseract"
+        first_line = (proc.stdout or "").splitlines()[0:1]
+        return first_line[0].strip() if first_line else "tesseract"
+
+    def _run(self, args: list[str]) -> subprocess.CompletedProcess[str]:
+        try:
+            proc = subprocess.run(
+                args,
+                capture_output=True,
+                text=True,
+                timeout=self.timeout_seconds,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as e:
+            LOGGER.warning("Tesseract command timed out after %ss.", self.timeout_seconds)
+            raise OcrError(f"Tesseract timed out after {self.timeout_seconds}s.") from e
+        except OSError as e:
+            LOGGER.warning("Failed to run Tesseract: %s", e)
+            raise OcrError(f"Failed to run Tesseract: {e}") from e
+        if proc.returncode != 0:
+            stderr = (proc.stderr or "").strip()
+            LOGGER.warning("Tesseract failed with exit code %s: %s", proc.returncode, stderr)
+            raise OcrError(f"Tesseract failed with exit code {proc.returncode}: {stderr}")
+        return proc
+
+
+def _parse_label(text: str, label: str) -> str | None:
+    pattern = re.compile(rf"^\s*{re.escape(label)}\s*:\s*(?P<value>.+?)\s*$", re.MULTILINE)
+    match = pattern.search(text)
+    return match.group("value").strip() if match else None
+
+
+def _parse_float_label(text: str, label: str) -> float | None:
+    value = _parse_label(text, label)
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        return None
+
+
+_DEFAULT_SCRIPT_LANGUAGES: dict[str, list[str]] = {
+    "Latin": ["eng", "fra", "deu", "spa", "ita", "por", "nld", "ron"],
+    "Greek": ["ell", "grc"],
+    "Cyrillic": ["rus", "ukr", "bul", "srp", "mkd"],
+    "Arabic": ["ara", "fas", "urd"],
+    "Han": ["chi_sim", "chi_tra"],
+    "Hiragana": ["jpn"],
+    "Katakana": ["jpn"],
+    "Hangul": ["kor"],
+    "Devanagari": ["hin", "san", "mar"],
+}

alysis_code/assets/owl/ascii/f-000.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                           ▟█▘  ▔▜█▀▔  ▔▀█        
+      ███████▆       ▅▆▇████▊ ▐▇ ▗▄▖ ▇▌ ▁█        
+      ▜███████▇     ███████▉      ▀  ▂▃▆██▇       
+       ████████▋     ██████▎        ▕██████▉      
+        ████████▖     ▜████▖       ▁███████▉      
+        ▜████████▄▄▄▄▃▃ ▜██▉       ▐███████▘      
+         ██████████████    ▜▆      ▁█████▛▘       
+                            ▝▀▀▀▀▀▀▀▀▀▀▀          
+                                                  

alysis_code/assets/owl/ascii/f-001.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆         ▂▅▆██▘ ▐▇ ▗▄▖ ▇▌  █        
+      ▜███████▇     ▗▇█████▘      ▀  ▂▆▆██▇       
+       ████████▋    ███████▎       ▗▇██████▉      
+        ████████▖    ▀█████▏      ▃████████▉      
+        ▜████████▄▄▄▄▃▃▀███▙     ▝▜████████       
+         ██████████████  ▔▀▜▆      ▔▀▀▀▀▔▟▛       
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-002.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆           ▅▆█▘ ▐▇ ▗▄▖ ▇▌  █        
+      ▜███████▇        ▅███▊      ▀  ▂▆▆██▇       
+       ████████▋     ▅█████▎     ▟█████████▉      
+        ████████▖    ██████▏    ▕██████████▉      
+        ▜████████▄▄▄▄▃█████▙      ▀▀███████▛      
+         ██████████████ ▔▔▀▜▆       ▔▔▝▀▀█▘       
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-003.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆             ▟▊ ▐▇ ▗▄▖▕▇▙▁▁█        
+      ▜███████▇         ▗▆█▊      ▀  █████▇       
+       ████████▋       ▟███▏    ▇██████████▉      
+        ████████▖    ▂█████▎     ▀█████████▉      
+        ▜████████▄▄▄▄██████▊       ▔▀▜█████▘      
+         ██████████████▀▀███▆▖        ▔▔▔█        
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-004.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆             ▟▊ ▐▇ ▗▄▖▁▇▙▁▁█        
+      ▜███████▇           ▇▊      ▀  █████▇       
+       ████████▋        ▟██▏    ▕██████████▉      
+        ████████▖      ████▎     ▔▜████████▉      
+        ▜████████▄▄▄▄▇█████▊        ▔▀▀▀▀██▘      
+         ███████████████████▆▖           █        
+                          ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-005.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆            ▂▕▊ ▐▇▁▗▄▖▁▇▙▁▁█        
+      ▜███████▇         ▗▆█▊      ▀  █████▇       
+       ████████▋       ▟███▏     ▜█████████▉      
+        ████████▖    ▂█████▎      ▝▜███████▉      
+        ▜████████▄▄▄▄██████▊         ▔▀▀▀██▘      
+         ██████████████▀▀███▆▖           █        
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-006.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆             ▟▊ ▐▇ ▗▄▖▁▇▙▁▁█        
+      ▜███████▇           ▇▊      ▀  █████▇       
+       ████████▋        ▟██▏    ▕██████████▉      
+        ████████▖      ████▎     ▔▜████████▉      
+        ▜████████▄▄▄▄▇█████▊        ▔▀▀▀▀██▘      
+         ███████████████████▆▖           █        
+                          ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-007.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆             ▟▊ ▐▇ ▗▄▖▕▇▙▁▁█        
+      ▜███████▇         ▗▆█▊      ▀  █████▇       
+       ████████▋       ▟███▏    ▇██████████▉      
+        ████████▖    ▂█████▎     ▀█████████▉      
+        ▜████████▄▄▄▄██████▊       ▔▀▜█████▘      
+         ██████████████▀▀███▆▖        ▔▔▔█        
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-008.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆           ▅▆█▘ ▐▇ ▗▄▖ ▇▌  █        
+      ▜███████▇        ▅███▊      ▀  ▂▆▆██▇       
+       ████████▋     ▅█████▎     ▟█████████▉      
+        ████████▖    ██████▏    ▕██████████▉      
+        ▜████████▄▄▄▄▃█████▙      ▀▀███████▛      
+         ██████████████ ▔▔▀▜▆       ▔▔▝▀▀█▘       
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+                                                  

alysis_code/assets/owl/ascii/f-009.txt

@@ -0,0 +1,13 @@
+                                                  
+                             ▝█▖      ▗█▘         
+                           ▝▜██▅▅▅▅▅▅▅██▛▘        
+                            ▟█▛▜█████▛▜██▖        
+                            █▘  ▔▜█▀▔  ▔▀█        
+      ███████▆         ▂▅▆▆█▊ ▐▇ ▗▄▖ ▇▌  █        
+      ▜███████▇     ▗▇█████▊      ▀  ▂▆▆██▇       
+       ████████▋    ███████▎       ▗▇██████▉      
+        ████████▖    ▀█████▏      ▃████████▉      
+        ▜████████▄▄▄▄▃▃▀███▙     ▝▜████████       
+         ██████████████  ▔▀▜▆      ▔▀▀▀▀▔▟▛       
+                            ▝▀▀▀▀▀▀▀▀▀▀▀▀         
+