Merge pull request #633 from Ciphey/bee-cleanup-colours

Clean up colours and make Ciphey more friendly

Author: SkeletalDemise

ciphey/basemods/Checkers/human.py

@@ -1,26 +1,37 @@
 from typing import Dict, Optional
 
 from ciphey.iface import Checker, Config, ParamSpec, registry
+from rich.console import Console
+from rich.markup import escape
+
+console = Console()
 
 
 @registry.register
 class HumanChecker(Checker[str]):
-    @staticmethod
-    def getParams() -> Optional[Dict[str, ParamSpec]]:
-        pass
 
-    def check(self, text: str) -> Optional[str]:
+    """
+    Uses the person's decision to determine plaintext
+    """
+
+    def check(self, ctext: str) -> Optional[str]:
         with self._config().pause_spinner_handle():
-            response = input(f"Result {text.__repr__()} (y/N): ").lower()
+            response = console.input(
+                f"Possible plaintext: [blue bold]{escape(ctext.__repr__())}[/blue bold] ([green]y[/green]/[red]N[/red]): "
+            )
         if response == "y":
             return ""
         elif response in ("n", ""):
             return None
         else:
-            return self.check(text)
+            return self.check(ctext)
 
     def getExpectedRuntime(self, text: str) -> float:
         return 1  # About a second
 
+    @staticmethod
+    def getParams() -> Optional[Dict[str, ParamSpec]]:
+        return None
+
     def __init__(self, config: Config):
         super().__init__(config)

ciphey/basemods/Checkers/what.py

@@ -3,20 +3,27 @@
 from ciphey.iface import Checker, Config, ParamSpec, T, registry
 from loguru import logger
 from pywhat import identifier
+from rich.console import Console
+
+console = Console()
 
 
 @registry.register
 class What(Checker[str]):
 
     """
     Uses PyWhat to determine plaintext with regexes
+    https://github.com/bee-san/pyWhat
     """
 
     def check(self, ctext: T) -> Optional[str]:
         logger.trace("Trying PyWhat checker")
         returned_regexes = self.id.identify(ctext, api=True)
         if len(returned_regexes["Regexes"]) > 0:
-            return returned_regexes["Regexes"][0]["Regex Pattern"]["Name"]
+            console.print(
+                f'\nI think the plaintext is a [yellow]{returned_regexes["Regexes"][0]["Regex Pattern"]["Name"]}[/yellow].'
+            )
+            return f'The plaintext is a [yellow]{returned_regexes["Regexes"][0]["Regex Pattern"]["Name"]}[/yellow].'
         return None
 
     def getExpectedRuntime(self, text: T) -> float:

ciphey/ciphey.py

@@ -18,14 +18,16 @@
 import click
 from appdirs import AppDirs
 from loguru import logger
-from rich import print
+from rich.console import Console
 from yaspin import yaspin
 from yaspin.spinners import Spinners
 
 from . import iface
 
 warnings.filterwarnings("ignore")
 
+console = Console()
+
 
 def decrypt(config: iface.Config, ctext: Any) -> Union[str, bytes]:
     """A simple alias for searching a ctext and makes the answer pretty"""
@@ -264,4 +266,4 @@ def all_procedure(ctx):
     if result is None:
         result = "Could not find any solutions."
 
-    print(result)
+    console.print(result)

ciphey/iface/_modules.py

@@ -1,11 +1,18 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Generic, List, NamedTuple, Optional, Set, Type, TypeVar
 
+from rich import box
+from rich.console import Console
+from rich.markup import escape
+from rich.table import Table
+
 from ._fwd import config as Config
 
 T = TypeVar("T")
 U = TypeVar("U")
 
+console = Console()
+
 
 class ParamSpec(NamedTuple):
     """
@@ -303,44 +310,58 @@ def __init__(self, config: Config):
 
 def pretty_search_results(res: SearchResult, display_intermediate: bool = False) -> str:
     ret: str = ""
-    if len(res.check_res) != 0:
-        ret += f"Checker: {res.check_res}\n"
-    ret += "Format used:\n"
+    table = Table(show_header=False, box=box.ROUNDED, safe_box=False)
+    # Only print the checker if we need to. Normal people don't know what
+    # "quadgrams", "brandon", "json checker" is.
+    # We print the checker if its regex or another language, so long as it starts with:
+    # "The" like "The plaintext is a Uniform Resource Locator (URL)."
+    if len(res.check_res) != 0 and "The" == res.check_res[0:3]:
+        ret += f"{res.check_res}\n"
 
     def add_one():
-        nonlocal ret
-        ret += f"  {i.name}"
+        out = ""
+        if i.name == "utf8":
+            out += f"   [#808080]{i.name}[/#808080]"
+        else:
+            out += f"   {i.name}"
         already_broken = False
         if i.result.key_info is not None:
-            ret += f":\n    Key: {i.result.key_info}\n"
+            out += f":\n    Key: {i.result.key_info}\n"
             already_broken = True
         if i.result.misc_info is not None:
             if not already_broken:
-                ret += ":\n"
-            ret += f"    Misc: {i.result.misc_info}\n"
+                out += ":\n"
+            out += f"    Misc: {i.result.misc_info}\n"
             already_broken = True
         if display_intermediate:
             if not already_broken:
-                ret += ":\n"
-            ret += f'    Value: "{i.result.value}"\n'
+                out += ":\n"
+            out += f'    Value: "{i.result.value}"\n'
             already_broken = True
         if not already_broken:
-            ret += "\n"
+            out += "\n"
+        return out
 
     # Skip the 'input' and print in order
+    out = ""
     for i in res.path[1:]:
-        add_one()
+        out += add_one()
+
+    if out:
+        if len(out.split("\n")) > 1:
+            ret += "Formats used:\n"
+        else:
+            ret += "Format used:\n"
+        ret += out
 
     # Remove trailing newline
     ret = ret[:-1]
 
     # If we didn't show intermediate steps, then print the final result
     if not display_intermediate:
-        ret += (
-            f"""\nFinal result: [bold green]"{res.path[-1].result.value}"[bold green]"""
-        )
-
-    return ret
+        ret += f"""\nPlaintext: [bold green]"{escape(res.path[-1].result.value)}"[bold green]"""
+    table.add_row(ret)
+    return table
 
 
 # Some common collection types