fontu 0.0.1__py3-none-any.whl

fontu-0.0.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: fontu
+Version: 0.0.1
+Summary: A CLI tool to shuffle glyphs in a local font and encrypt text (e.g., HTML files) using the shuffled font.
+Author: automatonomy.net
+Author-email: Andy Gajdošík <andreas@gajdosik.org>, Tomáš Zato <tomas@screensaver.gallery>
+Maintainer-email: Andy Gajdošík <andreas@gajdosik.org>
+Project-URL: Homepage, https://codeberg.org/automatonomy/fontu
+Project-URL: Issues, https://codeberg.org/automatonomy/fontu/issues
+Keywords: art,CLI,font,anti-AI,antiAI,AI,encoding
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: beautifulsoup4>=4.15
+Requires-Dist: fonttools>=4.63.0
+
+# FontU!
+
+Simple Python script to:
+1. shuffle characters of the text content of your HTML,
+2. accordingly (in reverse order) shuffle symbols in the font,
+3. add the font into your HTML,
+4. congratz, text contents of your HTML are machine unreadable, yet human can read it just fine.
+
+## Problems
+
+Text encrypted by FontU will not be readable by screen readers.
+We plan to investigate and fix this problem.
+Maybe we could manipulate the vocal files accordingly?
+If you have experience with screen readers, please let us know.
+We deeply appreciate your feedback and ideas.
+
+## Example commands
+
+For simple one-step encoding, run `do` subcommand and spefcify input HTML with an input font: 
+`python main.py do -i in_html/gajdosik-org_sample.html -f in_fonts/Roboto/Roboto-VariableFont_wdth,wght.ttf`
+
+Or alternatively first create a shuffled font and coresponding keymap holding about exact shuffle order:
+`python main.py wys -f in_fonts/Roboto/Roboto-VariableFont_wdth,wght.ttf`
+
+Then call `wtg` to use the keymap to encode HTML file and add decoding font to it automatically:
+`python main.py wtg -i in_html/gajdosik-org_sample.html -k private/fontu.json`
+
+## Credits
+
+Huge thanks to all authors and contributors of [fontTools](https://github.com/fonttools/fonttools).
+
+Thanks to MetroByte, their script [getfontchars.py](https://github.com/MetroByte/GetFontChars/blob/main/getfontchars.py) served me a as nice introductory example into `fontTools`.

fontu-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+main.py,sha256=q9xV34l9qKJ-HYR6DZP-qh8mlGBUM0Fgyu01K4H8nSg,15138
+fontu-0.0.1.dist-info/METADATA,sha256=xLBYU2vaB8bmXS6WzeV9iQWYC6qvOE8ObAw2VOY76fU,2337
+fontu-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fontu-0.0.1.dist-info/entry_points.txt,sha256=XTO9ZCb9LXVq21IVBTOHWUin3dgr88CAkYLAVpOeWeM,36
+fontu-0.0.1.dist-info/top_level.txt,sha256=ZAMgPdWghn6xTRBO6Kc3ML1y3ZrZLnjZlqbboKXc_AE,5
+fontu-0.0.1.dist-info/RECORD,,

fontu-0.0.1.dist-info/WHEEL

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

fontu-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fontu = main:main

fontu-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+main

main.py

@@ -0,0 +1,410 @@
+import argparse
+import random
+import os
+import json
+import pathlib
+import shutil
+
+from fontTools import ttLib
+from bs4 import BeautifulSoup, element
+
+SUPPORTED_FONTS = [".ttf"]
+
+# MARK: FONT SHUFFLING
+def shuffle_font(input_font: pathlib.Path, characters: str, seed:  int | float | str | bytes | bytearray | None) -> tuple[ttLib.TTFont, dict]:
+    """Get font, shuffle its selected characters and create a contra mapping to this shuffle. Use seed for the shuffle if provided.
+    Return the tuple (font, contra_mapping), so we can encode text content of the HTML accordingly.
+    """
+    if seed == "":
+        seed = None
+    input_font = pathlib.Path(input_font).absolute()
+    font = ttLib.TTFont(input_font)
+    unicode_cmaps = []
+    for table in font["cmap"].tables:
+        if table.isUnicode():
+            unicode_cmaps.append(table)
+
+    if not unicode_cmaps:
+        raise RuntimeError("No Unicode cmap table found in this font.")
+
+    codepoints = [ord(c) for c in characters]
+    print(f"Following characters will be shuffled {codepoints}")
+
+    source_cmap = unicode_cmaps[0].cmap
+    available_codepoints = [cp for cp in codepoints if cp in source_cmap]
+
+    if len(available_codepoints) < 2:
+        raise RuntimeError("Not enough selected characters exist in the font to shuffle.")
+
+    # Original mapping: Unicode codepoint -> glyph name
+    original_mapping = {}
+    for cp in available_codepoints:
+        original_mapping[cp] = source_cmap[cp]
+
+    shuffled_codepoints = available_codepoints[:]
+    while shuffled_codepoints == available_codepoints:
+        random.seed(seed)
+        random.shuffle(shuffled_codepoints)
+
+    new_mapping = {}
+    for new_cp, old_cp in zip(shuffled_codepoints, available_codepoints):
+        new_mapping[new_cp] = original_mapping[old_cp]
+
+    for cmap_table in unicode_cmaps:
+        for cp, glyph_name in new_mapping.items():
+            if cp not in cmap_table.cmap:
+                continue
+            cmap_table.cmap[cp] = glyph_name
+
+    contra_mapping = {}
+    print("[Character] will be shown as [character]")
+    for old_cp, new_cp in zip(available_codepoints, shuffled_codepoints):
+        displayed_char = chr(old_cp)
+        typed_char     = chr(new_cp)
+        old = f"{displayed_char!r}({old_cp})"
+        new = f"{typed_char!r}({new_cp})"
+        print(f"  {old:15}  ->          {new}")
+        contra_mapping[displayed_char] = typed_char
+
+    print("contra_mapping", contra_mapping)    
+    return font, contra_mapping
+
+# MARK: ENCODING
+def encode_text(text: str, mapping: dict):
+    """Encode text based on the mapping."""
+    output = ""
+    for character in text:
+        if character in mapping:
+            output = output + mapping[character]
+        else:
+            output = output + character
+    return output
+
+
+def encode_html(html_path: pathlib.Path, mapping: dict, font_name: str) -> BeautifulSoup:
+    """Encode HTML file using mapping. Inject font_name as default font. Save the result to out_dir."""
+    html_path = pathlib.Path(html_path).absolute()
+    with open(html_path, "rt") as f:
+        soup = BeautifulSoup(f, 'html.parser')
+
+    # get text based elements
+    elements = soup.find_all(string=True)
+    for elem in elements:
+        if isinstance(elem, (element.Doctype, element.Comment)):
+            continue
+        if elem is None or elem.parent is None:
+            continue
+        if elem.parent.name == "title":
+            continue
+        encoded = encode_text(elem.string, mapping)
+        print(f"{elem.parent.name}\n--{elem}\n->{encoded}\n")
+        elem.string.replace_with(encoded)
+
+    images = soup.find_all("img")
+    for image in images:
+        image["alt"] = encode_text(image.get("alt", ""), mapping)
+
+    # INJECT FONT AUTOMATICALLY
+    style_tag = soup.new_tag("style")
+    style_tag.string = f"""
+    @font-face {{
+    font-family: "FontuFont";
+    src: url("{font_name}") format("truetype");
+    font-weight: normal;
+    font-style: normal;
+    }}
+    html {{
+    font-family: "FontuFont", sans-serif;
+    }}
+    """ 
+    h = soup.find("head")
+    if h is not None:
+        h.append(style_tag)
+    else:
+        print("Could not find <head> element in the file, could not append font style.")
+        
+    return soup
+
+
+def get_basic_chars():
+    """Get characters from basic Unicode planes: Basic Latin,
+    Latin-1 Supplement, Latin Extended-A, Latin Extended-B and IPA Extensions.
+    Skip those chars which affects formatting etc., just the simple chars.
+    https://codepoints.net/basic_multilingual_plane
+    """
+    chars = ""
+    for x in range(33, 127):
+        chars = chars + chr(x)
+    for x in range(161, 688):
+        if x == 173:
+            continue
+        chars = chars + chr(x)
+    return chars
+
+
+def get_table_dict(table: dict, fonts: list) -> dict:
+    """Format is based on the fontu-js definition."""
+    return {
+        "table": table,
+        "fonts": fonts,
+    }
+
+# MARK: FILE OPERATIONS
+def save_encoded_html(soup: BeautifulSoup, dest: pathlib.Path):
+    dest = pathlib.Path(dest).absolute()
+    if not dest.parent.exists():
+        os.makedirs(dest.parent, exist_ok=True)
+    with open(dest, "wt") as file:
+        file.write(str(soup))
+    print(f"Saved encoded HTML file to: {dest}")
+
+
+def save_shuffled_font(font:ttLib.TTFont, dest: pathlib.Path):
+    dest = pathlib.Path(dest).absolute()
+    if not dest.parent.exists():
+        os.makedirs(dest.parent, exist_ok=True)
+    font.save(dest)
+    print(f"Saved shuffled font to: {dest}")
+
+
+def save_mapping_file(mapping: dict, font_name: str, file_path: pathlib.Path):
+    if not file_path.parent.exists():
+        os.makedirs(file_path.parent, exist_ok=True)
+    with open(file_path, "wt") as file:
+        t = get_table_dict(mapping, [font_name] )
+        file.write(json.dumps(t))
+    print(f"Mapping file successfully saved to {file_path}")
+
+
+def read_mapping_file(fp: pathlib.Path):
+    fp = pathlib.Path(fp)
+    if not fp.exists():
+        RuntimeError(f"Cannot read mapping file, file does not exist: {fp}")
+
+    with open(fp, "rt") as file:
+        data = json.load(file)
+
+    if "table" not in data.keys():
+        RuntimeError(f"Mapping file does not contain key 'table'")
+    if "fonts" not in data.keys():
+        RuntimeError(f"Mapping file does not contain key 'fonts'")
+    
+    return data["table"], data["fonts"]
+
+# MARK: CMD FUNCS
+def cmd_what_you_see(args):
+    input_font = validate_flag_input_font(args)
+    output_json = validate_flag_output_json(args)
+
+    font, mapping = shuffle_font(input_font, args.chars, args.seed)
+
+    output_font_name = output_json.stem + input_font.suffix
+    output_font_path = os.path.join(output_json.parent, output_font_name)
+    save_shuffled_font(font, output_font_path)
+    save_mapping_file(mapping, output_font_name, output_json)
+
+
+def cmd_what_they_get(args):
+    html_path = validate_flag_input_html(args)
+    out_dir = validate_flag_out_dir(args)
+    keymap_path = validate_flag_keymap(args)
+    
+    mapping, fonts = read_mapping_file(keymap_path)
+    
+    font = fonts[0] # TODO: discuss with Tomas if we really want multiple fonts.
+    input_font = keymap_path.parent.joinpath(font)
+    output_font = out_dir.joinpath(font)
+    shutil.copy(input_font, output_font)
+
+    soup = encode_html(html_path, mapping, font)
+    save_encoded_html(soup, out_dir.joinpath(html_path.name))
+
+
+def cmd_do(args):
+    input_font = validate_flag_input_font(args)
+    input_html = validate_flag_input_html(args)
+    out_dir = validate_flag_out_dir(args)
+    font_name = f"fontu-{input_font.name}"
+
+    font, mapping = shuffle_font(input_font, args.chars, args.seed)
+    save_shuffled_font(font, out_dir.joinpath(font_name))
+    
+    soup = encode_html(input_html, mapping, font_name)
+    save_encoded_html(soup, out_dir.joinpath(input_html.name))
+
+# MARK: VALIDATIONS
+def validate_flag_input_font(args) -> pathlib.Path:
+    input_font = pathlib.Path(args.font).absolute()
+    if not input_font.is_file():
+        raise RuntimeError("flag -font needs to be a path to a font file.")
+    if input_font.suffix.lower() not in SUPPORTED_FONTS:
+        raise RuntimeError(f"flag -font needs to be one of supported fonts: {SUPPORTED_FONTS}")
+    return input_font
+
+
+def validate_flag_input_html(args) -> pathlib.Path:
+    path = pathlib.Path(args.input_html).absolute()
+    if not path.exists():
+        raise RuntimeError(f"flag -input-html {path} needs to be an existing file.")
+    if path.is_dir():
+        raise RuntimeError(f"flag -input-html {path} needs to be a path to a HTML file, not directory.")
+    return path
+
+
+def validate_flag_out_dir(args) -> pathlib.Path:
+    path = pathlib.Path(args.out_dir).absolute()
+    if not path.exists():
+        os.makedirs(path, exist_ok=True)
+    if not path.is_dir():
+        raise RuntimeError(f"flag -out-dir {path} is not a directory.")
+    return path
+
+
+def validate_flag_keymap(args) -> pathlib.Path:
+    path = pathlib.Path(args.keymap).absolute()
+    if not path.exists():
+        raise RuntimeError(f"flag -keymap {path} needs to exist.")
+    if path.is_dir():
+        raise RuntimeError(f"flag -keymap {path} cannot be a directory.")
+    return path
+
+
+def validate_flag_output_json(args) -> pathlib.Path:
+    path = pathlib.Path(args.output).absolute()
+    if path.is_dir():
+        raise RuntimeError("flag -output needs to be a path to a JSON file, not a directory.")
+    if path.suffix != ".json":
+        raise RuntimeError("flag -output needs to be a JSON file.")
+    return path
+
+# MARK: MAIN
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog='fontu',
+        description='Encrypt the HTML text content and create a font which visually decrypts it. '
+        'The (plain)text is unreadable for the machines, but readable by humans if it is rendered using the one specific font.',
+        epilog='What you see is not what they get.'
+    )
+    subparser = parser.add_subparsers(
+        title='subcommands',
+        required=True,
+        description='',
+        help='',
+        metavar='',
+        )
+
+    # MARK: DO
+    do_help = ("Do the encoding process (wys and wtg) in a single step. "
+        "Take the specified font and shuffle its characters, then shuffle the text in the HTML in opposite direction. "
+        "This result in an HTML unreadable to machines, but readable to human eyes."
+    )
+    do = subparser.add_parser(
+        name="do",
+        aliases=["what-you-see-is-not-what-they-get", "wtf"],
+        help=do_help,
+        description=do_help + " " +
+            "This command does not save the mapping file. "
+            "In order to encode multiple HTML files using the same font, please use first 'wys' to get the mapping and then 'wtg' apply mapping to multiple files.",
+        )
+    do.add_argument(
+        "-i", "--input-html", type=str,
+        default="in_html/gajdosik-org_sample.html",
+        help="Path to input HTML file. "
+        "Text content of it will be encrypted using the Keymap. "
+        "A compatible decrypting font will be added to the style of the HTML."
+        )
+    do.add_argument(
+        "-f", "--font", type=str,
+        default="in_fonts/Roboto/Roboto-VariableFont_wdth,wght.ttf",
+        help="Path to an input font which will be shuffled. "
+        "Resulting font comes to the same directory as OUTPUT, sharing its name."
+    )
+    do.add_argument(
+        "-c", "--chars", type=str,
+        default=get_basic_chars(),
+        help="String of characters which should be used for shuffling. "
+        "If nothing is provided default string containing extended set of latin characters is used. "
+        "Characters unavailable in the font are skipped."
+        )
+    do.add_argument(
+        "-o", "--out-dir", type=str,
+        default="public",
+        help="Path to output directory where the encrypted HTML file will be saved. "
+        "The decryption font will be copied there as well."
+        )
+    do.add_argument(
+        "-s", "--seed", type=str,
+        help="Seed to be used for the random shuffling. Same seed should provide the same results. "
+        "If no seed is provided a default Python seed is used, which is a current time or random source from the OS."
+        )
+    do.set_defaults(func=cmd_do)
+
+    # MARK: WHAT-YOU-SEE
+    wys_help = (
+        "Create decryption font and map which can be later used to reproducibly encrypt text content of HTML files. "
+        "Resulting font and mapping can be used by <wtg> subcommand to encrypt HTML files."
+        )
+    wys = subparser.add_parser(
+        name="what-you-see",
+        aliases=["wys", "create"],
+        help=wys_help,
+        description=wys_help,
+        )
+    wys.add_argument(
+        "-f", "--font", type=str,
+        default="in_fonts/Roboto/Roboto-VariableFont_wdth,wght.ttf",
+        help="Path to an input font which will be shuffled. "
+        "Resulting font comes to the same directory as OUTPUT, sharing its name."
+    )
+    wys.add_argument(
+        "-c", "--chars", type=str,
+        default=get_basic_chars(),
+        help="String of characters which should be used for shuffling. "
+        "If nothing is provided default string containing extended set of latin characters is used. "
+        "Characters unavailable in the font are skipped."
+        )
+    wys.add_argument(
+        "-o", "--output", type=str,
+        default="private/fontu.json",
+        help="Path where resulting keymap JSON file should be saved. "
+        "It will contain the mapping of how characters should be shuffled. "
+        "Next to it the shuffled font with the same name as the mapping JSON will be saved."
+        )
+    wys.add_argument(
+        "-s", "--seed", type=str,
+        help="Seed to be used for the random shuffling. Same seed should provide the same results. "
+        "If no seed is provided a default Python seed is used, which is a current time or random source from the OS."
+        )
+    wys.set_defaults(func=cmd_what_you_see)
+
+    # MARK: WHAT THEY GET
+    wtg_help = "Encode the text content of specified HTML file. Add decryption font to it automatically."
+    wtg = subparser.add_parser(
+        name="what-they-get",
+        aliases=["wtg", "encode"],
+        help=wtg_help,
+        description=wtg_help,
+        )
+    wtg.add_argument(
+        "-i", "--input-html", type=str,
+        default="in_html/gajdosik-org_sample.html",
+        help="Path to input HTML file. "
+        "Text content of it will be encrypted using the Keymap. "
+        "A compatible decrypting font will be added to the style of the HTML."
+        )
+    wtg.add_argument(
+        "-k", "--keymap", type=str,
+        default="private/fontu.json",
+        help="Path to input keymap JSON file. "
+        "It contains information how to shuffle the characters and list of all fonts, which were shuffled in opossite way."
+        )
+    wtg.add_argument(
+        "-o", "--out-dir", type=str,
+        default="public",
+        help="Path to output directory where the encrypted HTML file will be saved. "
+        "The decryption font will be copied there as well."
+        )
+    wtg.set_defaults(func=cmd_what_they_get)
+
+    args = parser.parse_args()
+    args.func(args)