Convert python identifiers to some preselected Unicode characters

make_fancy_code.py

import ast
import os
import random
import string
import sys
import unicodedata as ud


class IdentifierTransformer(ast.NodeTransformer):
    def __init__(self, char_sets: dict[str, dict[str, list]]):
        self.char_sets = char_sets
        self._replaced_names = {}

    def update_name(self, name: str):
        if name in self._replaced_names:
            return self._replaced_names[name]

        lower_set_to_use = random.choice(list(self.char_sets['lower']))
        upper_set_to_use = lower_set_to_use
        # try to use the same set for upper case if available
        if upper_set_to_use not in self.char_sets['upper']:
            upper_set_to_use = random.choice(list(self.char_sets['upper']))

        new_name = ''
        for char in name:
            if char in string.ascii_lowercase:
                i = string.ascii_lowercase.index(char)
                new_name += self.char_sets['lower'][lower_set_to_use][i]
            elif char in string.ascii_uppercase:
                i = string.ascii_uppercase.index(char)
                new_name += self.char_sets['upper'][upper_set_to_use][i]
            else:
                new_name += char

        self._replaced_names[name] = new_name
        return new_name

    def visit_ImportFrom(self, node: ast.ImportFrom):
        for alias in node.names:
            alias.name = self.update_name(alias.name)

        if node.module is not None:
            node.module = self.update_name(node.module)
        return self.generic_visit(node)

    def visit_Import(self, node: ast.Import):
        for alias in node.names:
            alias.name = self.update_name(alias.name)
        return self.generic_visit(node)

    def visit_Attribute(self, node: ast.Attribute):
        node.attr = self.update_name(node.attr)
        return self.generic_visit(node)

    def visit_Name(self, node: ast.Name):
        node.id = self.update_name(node.id)
        return self.generic_visit(node)

    def visit_FunctionDef(self, node: ast.FunctionDef):
        node.name = self.update_name(node.name)
        return self.generic_visit(node)

    def visit_ClassDef(self, node: ast.ClassDef):
        node.name = self.update_name(node.name)
        return self.generic_visit(node)

    def visit_arg(self, node: ast.arg):
        node.arg = self.update_name(node.arg)
        return self.generic_visit(node)


def main():
    if len(sys.argv) != 3:
        print(f'Usage: python {sys.argv[0]} <input_file> <output_file>')
        return

    char_sets: dict[str, dict[str, list]] = {
        'lower': {
            'math1': [],
            'math2': [],
            'math3': [],
            'math4': [],
        },
        'upper': {
            'math1': [],
            'math2': [],
            'math3': [],
        },
    }

    for letter in string.ascii_uppercase:
        char_sets['lower']['math1'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL {letter}'))
        char_sets['lower']['math2'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF BOLD SMALL {letter}'))
        char_sets['lower']['math3'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF ITALIC SMALL {letter}'))
        char_sets['lower']['math4'].append(ud.lookup(f'MATHEMATICAL FRAKTUR SMALL {letter}'))
        char_sets['upper']['math1'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL {letter}'))
        char_sets['upper']['math2'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF BOLD CAPITAL {letter}'))
        char_sets['upper']['math3'].append(ud.lookup(f'MATHEMATICAL SANS-SERIF ITALIC CAPITAL {letter}'))
        # not all exist for FRAKTUR it seems... sad
        # char_sets['upper']['math4'].append(ud.lookup(f'MATHEMATICAL FRAKTUR CAPITAL {letter}'))

    with open(sys.argv[1], 'r', encoding='utf-8') as f:
        code = f.read()

    tree = ast.parse(code)
    new_tree = ast.fix_missing_locations(IdentifierTransformer(char_sets).visit(tree))

    if os.path.exists(sys.argv[2]):
        if input(f'File {sys.argv[2]} exists. Overwrite? [y/N] ').lower() != 'y':
            print('Aborting.')
            return

    with open(sys.argv[2], 'w', encoding='utf-8') as f:
        f.write(ast.unparse(new_tree))


if __name__ == '__main__':
    main()

Applied on this: https://gist.github.com/nitori/e9704b249526296c1e5701cd9822cbf7

import 𝘀𝘆𝘀

def 𝔦𝔫𝔱_𝔰𝔲𝔠𝔠𝔢𝔢𝔡𝔰(𝔠: 𝙨𝙩𝙧):
    try:
        𝘪𝘯𝘵(𝔠)
    except 𝘝𝘢𝘭𝘶𝘦𝘌𝘳𝘳𝘰𝘳:
        return False
    return True
𝘤𝘩𝘢𝘳𝘴 = [𝘤𝘩𝘳(𝔫) for 𝔫 in 𝙧𝙖𝙣𝙜𝙚(𝘀𝘆𝘀.𝙢𝙖𝙭𝙪𝙣𝙞𝙘𝙤𝙙𝙚 + 1)]
𝔫𝔲𝔪𝔢𝔯𝔦𝔠𝔰 = {𝔠 for 𝔠 in 𝘤𝘩𝘢𝘳𝘴 if 𝔠.𝗶𝘀𝗻𝘂𝗺𝗲𝗿𝗶𝗰()}
𝘥𝘪𝘨𝘪𝘵𝘴 = {𝔠 for 𝔠 in 𝘤𝘩𝘢𝘳𝘴 if 𝔠.𝙞𝙨𝙙𝙞𝙜𝙞𝙩()}
𝘥𝘦𝘤𝘪𝘮𝘢𝘭𝘴 = {𝔠 for 𝔠 in 𝘤𝘩𝘢𝘳𝘴 if 𝔠.𝘪𝘴𝘥𝘦𝘤𝘪𝘮𝘢𝘭()}
𝗽𝗿𝗶𝗻𝘁('No. numerics:', 𝘭𝘦𝘯(𝔫𝔲𝔪𝔢𝔯𝔦𝔠𝔰))
𝗽𝗿𝗶𝗻𝘁('No. digits:', 𝘭𝘦𝘯(𝘥𝘪𝘨𝘪𝘵𝘴))
𝗽𝗿𝗶𝗻𝘁('No. decimals:', 𝘭𝘦𝘯(𝘥𝘦𝘤𝘪𝘮𝘢𝘭𝘴))
𝗽𝗿𝗶𝗻𝘁('numerics ⊃ digits ⊃ decimals:', 𝔫𝔲𝔪𝔢𝔯𝔦𝔠𝔰 > 𝘥𝘪𝘨𝘪𝘵𝘴 > 𝘥𝘦𝘤𝘪𝘮𝘢𝘭𝘴)
𝗽𝗿𝗶𝗻𝘁('int() on numerics:', 𝔞𝔩𝔩((𝔦𝔫𝔱_𝔰𝔲𝔠𝔠𝔢𝔢𝔡𝔰(𝔠) for 𝔠 in 𝔫𝔲𝔪𝔢𝔯𝔦𝔠𝔰)))
𝗽𝗿𝗶𝗻𝘁('int() on digits:', 𝔞𝔩𝔩((𝔦𝔫𝔱_𝔰𝔲𝔠𝔠𝔢𝔢𝔡𝔰(𝔠) for 𝔠 in 𝘥𝘪𝘨𝘪𝘵𝘴)))
𝗽𝗿𝗶𝗻𝘁('int() on decimals:', 𝔞𝔩𝔩((𝔦𝔫𝔱_𝔰𝔲𝔠𝔠𝔢𝔢𝔡𝔰(𝔠) for 𝔠 in 𝘥𝘦𝘤𝘪𝘮𝘢𝘭𝘴)))