zhmiscellany 6.1.1__py3-none-any.whl → 6.1.3__py3-none-any.whl

zhmiscellany/misc.py

@@ -258,441 +258,440 @@ def die_on_key(key='f9', show_message=False):
         die()
     zhmiscellany.processing.start_daemon(target=_die_on_key, args=(key,))
 
+if WIN32_AVAILABLE:
+    temp_folder = os.popen(r'echo %TEMP%').read().replace('\n', '')
+
+    def obfuscate_python(python_code_string, do_not_obfuscate_indent_block_comment='# DNO', remove_prints=True, remove_comments=True, add_lines=True, new_line_ratio=10):
+        import keyword
+
+        obf = python_code_string
+        dno_sig = do_not_obfuscate_indent_block_comment
+        dno_char = '2LAM67M4'
+
+        if add_lines:
+            remove_comments = True  # Sorry, right now it has to be like this, and I'm too lazy to implement this in a better way. Why would you not want to remove comments anyway...
+
+        if remove_prints or remove_comments:
+            lines = obf.split('\n')
+            for i, line in enumerate(lines):
+                if remove_prints:
+                    if line.replace(' ', '').startswith('print('):
+                        j = 0
+                        for j, char in enumerate(line):
+                            if char != ' ':
+                                break
+                        lines[i] = f'{" "*j}pass'
+                has_dno = line.endswith(dno_sig)
+                if remove_comments:
+                    lines[i] = lines[i].split('#')[0]
+                if has_dno:
+                    lines[i] = lines[i] + ' ' + dno_char
+            obf = '\n'.join(lines)
+            lines = obf.split('\n')
+            lines = [line for line in lines if not any([set(line) == set(j) for j in ['', ' ']])]
+            obf = '\n'.join(lines)
+
+        if add_lines:
+            # gather reserved strings
+            reserved = []
+            reserved.extend(keyword.kwlist)  # keywords
+            reserved.extend(dir(builtins))  # functions/constants
+            reserved.extend([attr for attr in dir(object) if attr.startswith('__') and attr.endswith('__')])  # dunders
+            reserved.extend([name for name, obj in vars(builtins).items() if inspect.isclass(obj) and issubclass(obj, BaseException)])  # exceptions
+            # tokenize file
+            base_splits = '\n\\!#$%&()*+,-./:;<=>?@[\]^`{|}~'
+            var_splits = base_splits + ' "\''
+            token_splits = base_splits + ' _'
+            possible_existing_variables = zhmiscellany.string.multi_split(obf, list(var_splits))
+            tokens = zhmiscellany.string.multi_split(obf, list(token_splits))
+            tokens = [token for token in tokens if all([char in list(string.ascii_letters + string.digits + "_") for char in token])]
+            tokens = [token for token in tokens if dno_char not in token]
+            tokens = [token for token in tokens if token not in reserved]
+            tokens = list(dict.fromkeys(tokens))
+            number_tokens = [token for token in tokens if all([char in '1234567890' for char in token])]
+            #number_tokens = [token for token in number_tokens if set(token) != set('0')]
+            number_tokens = [token for token in number_tokens if not token.startswith('0')]
+            all_tkns = copy.deepcopy(tokens)
+            for i in number_tokens:
+                tokens.remove(i)
+            number_tokens = [num for num in number_tokens if len(str(num)) < 10000]
+
+
+            base_rng = random.Random(0.26900750624933856)
+
+            rngs = {
+                'num_rng': random.Random(base_rng.random()),
+                'var_name_rng': random.Random(base_rng.random()),
+                'str_rng': random.Random(base_rng.random()),
+                'lst_rng': random.Random(base_rng.random()),
+                'new_rng': random.Random(base_rng.random()),
+                'global_rng': random.Random(base_rng.random()),
+                'match_rng': random.Random(base_rng.random()),
+                'create_var_name': random.Random(base_rng.random()),
+                'make_random_number': random.Random(base_rng.random()),
+                'create_string': random.Random(base_rng.random()),
+                'create_list': random.Random(base_rng.random()),
+            }
+
+
+            if not number_tokens:
+                def make_random_number():
+                    ends = [10, 100, 1000]
+                    return rngs['make_random_number'].randint(0, rngs['make_random_number'].choice(ends))
+                number_tokens = [make_random_number for i in range(round((len(obf.split('\n'))*new_line_ratio)/10))]
+            total_new_lines = len(obf.split('\n'))*new_line_ratio
+
+            def create_var_name(vars):
+                while True:
+                    var = rngs['create_var_name'].choice(tokens)
+                    while True:
+                        if var[0] in list('1234567890'):
+                            break
+                        if var not in possible_existing_variables and var not in vars['all']:
+                            if rngs['create_var_name'].random() > 1/3:
+                                return var
+                        var = var + '_' + random.choice(tokens)
 
-temp_folder = os.popen(r'echo %TEMP%').read().replace('\n', '')
+            def create_string(nds=None):
+                stri = rngs['create_string'].choice(all_tkns)
 
+                if not nds:
+                    stnds = ['"', "'", '"""', "'''"]
+                    nds = rngs['create_string'].choice(stnds)
 
-def obfuscate_python(python_code_string, do_not_obfuscate_indent_block_comment='# DNO', remove_prints=True, remove_comments=True, add_lines=True, new_line_ratio=10):
-    import keyword
-    
-    obf = python_code_string
-    dno_sig = do_not_obfuscate_indent_block_comment
-    dno_char = '2LAM67M4'
-
-    if add_lines:
-        remove_comments = True  # Sorry, right now it has to be like this, and I'm too lazy to implement this in a better way. Why would you not want to remove comments anyway...
-
-    if remove_prints or remove_comments:
-        lines = obf.split('\n')
-        for i, line in enumerate(lines):
-            if remove_prints:
-                if line.replace(' ', '').startswith('print('):
-                    j = 0
-                    for j, char in enumerate(line):
-                        if char != ' ':
-                            break
-                    lines[i] = f'{" "*j}pass'
-            has_dno = line.endswith(dno_sig)
-            if remove_comments:
-                lines[i] = lines[i].split('#')[0]
-            if has_dno:
-                lines[i] = lines[i] + ' ' + dno_char
-        obf = '\n'.join(lines)
-        lines = obf.split('\n')
-        lines = [line for line in lines if not any([set(line) == set(j) for j in ['', ' ']])]
-        obf = '\n'.join(lines)
-
-    if add_lines:
-        # gather reserved strings
-        reserved = []
-        reserved.extend(keyword.kwlist)  # keywords
-        reserved.extend(dir(builtins))  # functions/constants
-        reserved.extend([attr for attr in dir(object) if attr.startswith('__') and attr.endswith('__')])  # dunders
-        reserved.extend([name for name, obj in vars(builtins).items() if inspect.isclass(obj) and issubclass(obj, BaseException)])  # exceptions
-        # tokenize file
-        base_splits = '\n\\!#$%&()*+,-./:;<=>?@[\]^`{|}~'
-        var_splits = base_splits + ' "\''
-        token_splits = base_splits + ' _'
-        possible_existing_variables = zhmiscellany.string.multi_split(obf, list(var_splits))
-        tokens = zhmiscellany.string.multi_split(obf, list(token_splits))
-        tokens = [token for token in tokens if all([char in list(string.ascii_letters + string.digits + "_") for char in token])]
-        tokens = [token for token in tokens if dno_char not in token]
-        tokens = [token for token in tokens if token not in reserved]
-        tokens = list(dict.fromkeys(tokens))
-        number_tokens = [token for token in tokens if all([char in '1234567890' for char in token])]
-        #number_tokens = [token for token in number_tokens if set(token) != set('0')]
-        number_tokens = [token for token in number_tokens if not token.startswith('0')]
-        all_tkns = copy.deepcopy(tokens)
-        for i in number_tokens:
-            tokens.remove(i)
-        number_tokens = [num for num in number_tokens if len(str(num)) < 10000]
-
-
-        base_rng = random.Random(0.26900750624933856)
-
-        rngs = {
-            'num_rng': random.Random(base_rng.random()),
-            'var_name_rng': random.Random(base_rng.random()),
-            'str_rng': random.Random(base_rng.random()),
-            'lst_rng': random.Random(base_rng.random()),
-            'new_rng': random.Random(base_rng.random()),
-            'global_rng': random.Random(base_rng.random()),
-            'match_rng': random.Random(base_rng.random()),
-            'create_var_name': random.Random(base_rng.random()),
-            'make_random_number': random.Random(base_rng.random()),
-            'create_string': random.Random(base_rng.random()),
-            'create_list': random.Random(base_rng.random()),
-        }
-
-
-        if not number_tokens:
-            def make_random_number():
-                ends = [10, 100, 1000]
-                return rngs['make_random_number'].randint(0, rngs['make_random_number'].choice(ends))
-            number_tokens = [make_random_number for i in range(round((len(obf.split('\n'))*new_line_ratio)/10))]
-        total_new_lines = len(obf.split('\n'))*new_line_ratio
-
-        def create_var_name(vars):
-            while True:
-                var = rngs['create_var_name'].choice(tokens)
                 while True:
-                    if var[0] in list('1234567890'):
-                        break
-                    if var not in possible_existing_variables and var not in vars['all']:
-                        if rngs['create_var_name'].random() > 1/3:
-                            return var
-                    var = var + '_' + random.choice(tokens)
-
-        def create_string(nds=None):
-            stri = rngs['create_string'].choice(all_tkns)
-
-            if not nds:
+                    if rngs['create_string'].random() > 1/3:
+                        stri = stri + ' ' + rngs['create_string'].choice(all_tkns)
+                    else:
+                        return nds + stri + nds
+
+            def create_list(vars, will_run=True):
+                lst_str = '['
+                elements = []
+                end = 2
+                if not will_run:
+                    end = 3
+                chz = rngs['create_list'].randint(1, end)
                 stnds = ['"', "'", '"""', "'''"]
-                nds = rngs['create_string'].choice(stnds)
-
-            while True:
-                if rngs['create_string'].random() > 1/3:
-                    stri = stri + ' ' + rngs['create_string'].choice(all_tkns)
-                else:
-                    return nds + stri + nds
-
-        def create_list(vars, will_run=True):
-            lst_str = '['
-            elements = []
-            end = 2
-            if not will_run:
-                end = 3
-            chz = rngs['create_list'].randint(1, end)
-            stnds = ['"', "'", '"""', "'''"]
-            nds = rngs['create_list'].choice(stnds)
-            while True:
-                if rngs['create_list'].random() > 1/6:
-                    match chz:
-                        case 1:
-                            elements.append(create_string(nds))
-                        case 2:
-                            elements.append(rngs['create_list'].choice(number_tokens))
-                        case 3:
-                            elements.append(rngs['create_list'].choice(vars['all']))
-                else:
-                    break
-            lst_str = lst_str + ', '.join(elements)
-            lst_str = lst_str + ']'
-            return lst_str
-
-        varis = {
-            'added_lines': [],
-            'all': [],
-            'num': [],
-            'str': [],
-            'lst': [],
-            'fun': [],
-        }
-        prev = ''
-
-        rngs['gen_num_var'] = random.Random(base_rng.random())
-        rngs['gen_str_var'] = random.Random(base_rng.random())
-        rngs['gen_lst_var'] = random.Random(base_rng.random())
-        rngs['rand_num'] = random.Random(base_rng.random())
-        rngs['rand_var'] = random.Random(base_rng.random())
-        rngs['rand_loop'] = random.Random(base_rng.random())
-        rngs['rand_num_add'] = random.Random(base_rng.random())
-        rngs['rand_num_sub'] = random.Random(base_rng.random())
-        rngs['rand_str'] = random.Random(base_rng.random())
-        rngs['rand_print'] = random.Random(base_rng.random())
-        rngs['rand_lst'] = random.Random(base_rng.random())
-        rngs['add_pass'] = random.Random(base_rng.random())
-        rngs['add_random_line'] = random.Random(base_rng.random())
-        rngs['rand_var_add'] = random.Random(base_rng.random())
-        rngs['rand_var_sub'] = random.Random(base_rng.random())
-        rngs['gen_other_var'] = random.Random(base_rng.random())
-        rngs['rand_func'] = random.Random(base_rng.random())
-        rngs['rand_call_func'] = random.Random(base_rng.random())
-
-        dno_indent = None
-
-        for i, line in enumerate(lines):
-            indent = 0
-            for char in line:
-                if char == ' ':
-                    indent += 1
-                else:
-                    break
-            single_indent = 4 if indent % 4 == 0 else 2
-            varis['indent'] = indent
-
-            if line.endswith(dno_char) or indent == dno_indent:
-                dno_indent = indent
-                continue
-            else:
-                dno_indent = None
-
-
-            def gen_num_var(vars):
-
-                if 1 / 4 > rngs['gen_num_var'].random() and vars['num']:
-                    cvar = rngs['gen_num_var'].choice(vars['num'])
-                else:
-                    cvar = create_var_name(vars)
-                    vars['num'].append(cvar)
-                    vars['all'].append(cvar)
-
-                return cvar
-
-            def gen_str_var(vars):
-
-                non_num = []
-                non_num.extend(vars['str'])
-                non_num.extend(vars['lst'])
-
-                if 1 / 4 > rngs['gen_str_var'].random() and non_num:
-                    cvar = rngs['gen_str_var'].choice(non_num)
-                else:
-                    cvar = create_var_name(vars)
-                    vars['str'].append(cvar)
-                    vars['all'].append(cvar)
-
-                return cvar
-
-            def gen_lst_var(vars):
-
-                non_num = []
-                non_num.extend(vars['str'])
-                non_num.extend(vars['lst'])
+                nds = rngs['create_list'].choice(stnds)
+                while True:
+                    if rngs['create_list'].random() > 1/6:
+                        match chz:
+                            case 1:
+                                elements.append(create_string(nds))
+                            case 2:
+                                elements.append(rngs['create_list'].choice(number_tokens))
+                            case 3:
+                                elements.append(rngs['create_list'].choice(vars['all']))
+                    else:
+                        break
+                lst_str = lst_str + ', '.join(elements)
+                lst_str = lst_str + ']'
+                return lst_str
+
+            varis = {
+                'added_lines': [],
+                'all': [],
+                'num': [],
+                'str': [],
+                'lst': [],
+                'fun': [],
+            }
+            prev = ''
+
+            rngs['gen_num_var'] = random.Random(base_rng.random())
+            rngs['gen_str_var'] = random.Random(base_rng.random())
+            rngs['gen_lst_var'] = random.Random(base_rng.random())
+            rngs['rand_num'] = random.Random(base_rng.random())
+            rngs['rand_var'] = random.Random(base_rng.random())
+            rngs['rand_loop'] = random.Random(base_rng.random())
+            rngs['rand_num_add'] = random.Random(base_rng.random())
+            rngs['rand_num_sub'] = random.Random(base_rng.random())
+            rngs['rand_str'] = random.Random(base_rng.random())
+            rngs['rand_print'] = random.Random(base_rng.random())
+            rngs['rand_lst'] = random.Random(base_rng.random())
+            rngs['add_pass'] = random.Random(base_rng.random())
+            rngs['add_random_line'] = random.Random(base_rng.random())
+            rngs['rand_var_add'] = random.Random(base_rng.random())
+            rngs['rand_var_sub'] = random.Random(base_rng.random())
+            rngs['gen_other_var'] = random.Random(base_rng.random())
+            rngs['rand_func'] = random.Random(base_rng.random())
+            rngs['rand_call_func'] = random.Random(base_rng.random())
+
+            dno_indent = None
+
+            for i, line in enumerate(lines):
+                indent = 0
+                for char in line:
+                    if char == ' ':
+                        indent += 1
+                    else:
+                        break
+                single_indent = 4 if indent % 4 == 0 else 2
+                varis['indent'] = indent
 
-                if 1 / 4 > rngs['gen_lst_var'].random() and non_num:
-                    cvar = rngs['gen_lst_var'].choice(non_num)
+                if line.endswith(dno_char) or indent == dno_indent:
+                    dno_indent = indent
+                    continue
                 else:
-                    cvar = create_var_name(vars)
-                    vars['lst'].append(cvar)
-                    vars['all'].append(cvar)
+                    dno_indent = None
 
-                return cvar
 
-            def gen_func_var(vars):
-                cvar = create_var_name(vars)
-                vars['fun'].append(cvar)
-                vars['all'].append(cvar)
+                def gen_num_var(vars):
 
-                return cvar
-
-            def gen_other_var(vars):
-                cvar = create_var_name(vars)
-                vars['all'].append(cvar)
-                return cvar
-
-            while rngs['global_rng'].random() > 1/(new_line_ratio*2) and (not any([prev.endswith(char) for char in list(' ,\\[{(')+reserved])) and (not any([char in line for char in ':'])):
+                    if 1 / 4 > rngs['gen_num_var'].random() and vars['num']:
+                        cvar = rngs['gen_num_var'].choice(vars['num'])
+                    else:
+                        cvar = create_var_name(vars)
+                        vars['num'].append(cvar)
+                        vars['all'].append(cvar)
 
-                def rand_num(vars, will_run=True):  # var (new/old) to random int
-                    cvar = gen_num_var(vars)
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {rngs['rand_num'].choice(number_tokens)}"))
                     return cvar
 
-                def rand_var(vars, will_run=False):  # var (new/old) to random previous var
-                    if will_run:
-                        raise Exception('This should not be possible')
+                def gen_str_var(vars):
 
-                    if vars['all']:
-                        ev = rngs['rand_var'].choice(vars['all'])
-                    else:
-                        add_random_line(vars, will_run)
-                        return
+                    non_num = []
+                    non_num.extend(vars['str'])
+                    non_num.extend(vars['lst'])
 
-                    if ev in vars['num']:
-                        cvar = gen_num_var(vars)
-                    elif ev in vars['str']:
-                        cvar = gen_str_var(vars)
-                    elif ev in vars['lst']:
-                        cvar = gen_lst_var(vars)
+                    if 1 / 4 > rngs['gen_str_var'].random() and non_num:
+                        cvar = rngs['gen_str_var'].choice(non_num)
                     else:
-                        cvar = gen_other_var(vars)
-
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {ev}"))
-                    return cvar
+                        cvar = create_var_name(vars)
+                        vars['str'].append(cvar)
+                        vars['all'].append(cvar)
 
-                def rand_loop(vars, cvar, will_run=True):
-                    if rngs['rand_loop'].random() > 1/(new_line_ratio/4):
-                        return
-                    end = 1
-                    if cvar in vars['num']:
-                        end = 2
-                    choice = rngs['rand_loop'].randint(1, end)
-                    match choice:
-                        case 1:
-                            vars['added_lines'].append((i, f"{' ' * vars['indent']}while {cvar}:"))
-                        case 2:
-                            vars['added_lines'].append((i, f"{' ' * vars['indent']}for {gen_other_var(vars)} in range(0, {cvar}):"))
-
-                    vars['indent'] += single_indent
-                    f = True
-                    while rngs['rand_loop'].random() > 1 / (new_line_ratio * 2) or f:
-                        add_random_line(vars, False)
-                        f = False
-                    vars['indent'] -= single_indent
-
-                def rand_func(vars, will_run=True):
-                    if rngs['rand_func'].random() > 1/(new_line_ratio):
-                        add_random_line(vars, will_run)
-                        return
-                    cvar = gen_func_var(vars)
-                    ev = []
-                    while rngs['rand_func'].random() < 1/3:
-                        ev.append(create_var_name(vars))
-                    ev = ', '.join(ev)
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}def {cvar}({ev}):"))
-                    vars['indent'] += single_indent
-                    cvars = []
-                    while rngs['rand_func'].random() > 1 / (new_line_ratio * 2) or len([e for e in cvars if e]) == 0:
-                        cvars.append(add_random_line(vars, will_run))
-                    cvars = [e for e in cvars if e]
-                    ev = []
-                    f = True
-                    while rngs['rand_func'].random() < 1/3 or f:
-                        ev.append(rngs['rand_func'].choice(cvars))
-                        f = False
-                    ev = ', '.join(ev)
-                    if rngs['rand_func'].random() > 1/3:
-                        vars['added_lines'].append((i, f"{' ' * vars['indent']}return {ev}"))
-                    vars['indent'] -= single_indent
                     return cvar
 
-                def rand_call_func(vars, will_run=True):
-                    if (not vars['fun']) or will_run:
-                        add_random_line(vars, will_run)
-                        return
-                    func = rngs['rand_call_func'].choice(vars['fun'])
-                    ev = []
-                    while rngs['rand_call_func'].random() < 1/3:
-                        ev.append(rngs['rand_call_func'].choice(vars['all']))
-                    ev = ', '.join(ev)
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{func}({ev})"))
-
-                def rand_num_add(vars, will_run=True):  # var (new/old) to random int + random int
-                    cvar = gen_num_var(vars)
-                    pos1 = rngs['rand_num_add'].choice(number_tokens)
-                    pos2 = rngs['rand_num_add'].choice(number_tokens)
-                    falsy = False
-                    chz = rngs['rand_var_add'].randint(1, 3)
-                    match chz:
-                        case 1:
-                            pos3 = '+'
-                            if not (int(pos1) + int(pos2)): falsy = True
-                        case 2:
-                            pos3 = '-'
-                            if not (int(pos1) - int(pos2)): falsy = True
-                        case 3:
-                            pos3 = '*'
-                            if not (int(pos1) * int(pos2)): falsy = True
-
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {pos1} {pos3} {pos2}"))
-                    if falsy:
-                        rand_loop(vars, cvar)
-                    return cvar
+                def gen_lst_var(vars):
 
-                def rand_var_add(vars, will_run=False):  # var (new/old) to random int + random int
-                    if will_run:
-                        raise Exception('This should not be possible')
-                    cvar = gen_num_var(vars)
-
-                    chz = rngs['rand_var_add'].randint(1, 2)
-                    match chz:
-                        case 1:pos1 = rngs['rand_var_add'].choice(number_tokens)
-                        case 2:pos1 = rngs['rand_var_add'].choice(vars['all'])
-
-                    chz = rngs['rand_var_add'].randint(1, 2)
-                    match chz:
-                        case 1:pos2 = rngs['rand_var_add'].choice(number_tokens)
-                        case 2:pos2 = rngs['rand_var_add'].choice(vars['all'])
-
-                    chz = rngs['rand_var_add'].randint(1, 7)
-                    match chz:
-                        case 1:pos3 = '+'
-                        case 2:pos3 = '-'
-                        case 3:pos3 = '/'
-                        case 4:pos3 = '//'
-                        case 5:pos3 = '%'
-                        case 6:pos3 = '*'
-                        case 7:pos3 = '**'
-
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {pos1} {pos3} {pos2}"))
-                    return cvar
+                    non_num = []
+                    non_num.extend(vars['str'])
+                    non_num.extend(vars['lst'])
 
-                def rand_str(vars, will_run=True):  # var (new/old) to random string
-                    cvar = gen_str_var(vars)  # impossible for this to be falsy
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {create_string()}"))
-                    return cvar
+                    if 1 / 4 > rngs['gen_lst_var'].random() and non_num:
+                        cvar = rngs['gen_lst_var'].choice(non_num)
+                    else:
+                        cvar = create_var_name(vars)
+                        vars['lst'].append(cvar)
+                        vars['all'].append(cvar)
 
-                def rand_print(vars, will_run=False):  # print 1 random var or 2 random string or 3 random int or 4 random list
-                    if will_run:
-                        raise Exception('This should not be possible')
-                    cvar = gen_str_var(vars)
-                    choice = rngs['rand_print'].randint(1, 4)
-                    match choice:
-                        case 1:
-                            ev = rngs['rand_print'].choice(vars['all'])
-                        case 2:
-                            ev = create_string()
-                        case 3:
-                            ev = rngs['rand_print'].choice(number_tokens)
-                        case 4:
-                            ev = create_list(vars)
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}print({ev})"))
-
-                def rand_lst(vars, will_run=True):  # var (new/old) to random list
-                    lst = create_list(vars, will_run)
-                    cvar = gen_lst_var(vars)
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {lst}"))
-                    if lst == '[]':  # this will miss some but vast majority will be caught
-                        rand_loop(vars, cvar)
                     return cvar
 
-                def add_pass(vars, will_run=True):  # pass
-                    vars['added_lines'].append((i, f"{' ' * vars['indent']}pass"))
-
-                run_vars = [rand_num, rand_num_add, rand_str, rand_lst, add_pass, rand_func]
-                all_vars = run_vars + [rand_var, rand_print, rand_var_add, rand_call_func]
+                def gen_func_var(vars):
+                    cvar = create_var_name(vars)
+                    vars['fun'].append(cvar)
+                    vars['all'].append(cvar)
 
-                def add_random_line(vars, will_run=True):
-                    if will_run:
-                        line_variations = run_vars
-                    else:
-                        line_variations = all_vars
-                    variation = rngs['add_random_line'].choice(line_variations)
-                    cvar = variation(vars, will_run)
                     return cvar
 
-                add_random_line(varis)
+                def gen_other_var(vars):
+                    cvar = create_var_name(vars)
+                    vars['all'].append(cvar)
+                    return cvar
 
-            prev = line
+                while rngs['global_rng'].random() > 1/(new_line_ratio*2) and (not any([prev.endswith(char) for char in list(' ,\\[{(')+reserved])) and (not any([char in line for char in ':'])):
 
-        varis['added_lines'].reverse()
-        for line in varis['added_lines']:
-            lines.insert(line[0], line[1])
-        obf = '\n'.join(lines)
+                    def rand_num(vars, will_run=True):  # var (new/old) to random int
+                        cvar = gen_num_var(vars)
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {rngs['rand_num'].choice(number_tokens)}"))
+                        return cvar
+
+                    def rand_var(vars, will_run=False):  # var (new/old) to random previous var
+                        if will_run:
+                            raise Exception('This should not be possible')
+
+                        if vars['all']:
+                            ev = rngs['rand_var'].choice(vars['all'])
+                        else:
+                            add_random_line(vars, will_run)
+                            return
+
+                        if ev in vars['num']:
+                            cvar = gen_num_var(vars)
+                        elif ev in vars['str']:
+                            cvar = gen_str_var(vars)
+                        elif ev in vars['lst']:
+                            cvar = gen_lst_var(vars)
+                        else:
+                            cvar = gen_other_var(vars)
+
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {ev}"))
+                        return cvar
+
+                    def rand_loop(vars, cvar, will_run=True):
+                        if rngs['rand_loop'].random() > 1/(new_line_ratio/4):
+                            return
+                        end = 1
+                        if cvar in vars['num']:
+                            end = 2
+                        choice = rngs['rand_loop'].randint(1, end)
+                        match choice:
+                            case 1:
+                                vars['added_lines'].append((i, f"{' ' * vars['indent']}while {cvar}:"))
+                            case 2:
+                                vars['added_lines'].append((i, f"{' ' * vars['indent']}for {gen_other_var(vars)} in range(0, {cvar}):"))
+
+                        vars['indent'] += single_indent
+                        f = True
+                        while rngs['rand_loop'].random() > 1 / (new_line_ratio * 2) or f:
+                            add_random_line(vars, False)
+                            f = False
+                        vars['indent'] -= single_indent
+
+                    def rand_func(vars, will_run=True):
+                        if rngs['rand_func'].random() > 1/(new_line_ratio):
+                            add_random_line(vars, will_run)
+                            return
+                        cvar = gen_func_var(vars)
+                        ev = []
+                        while rngs['rand_func'].random() < 1/3:
+                            ev.append(create_var_name(vars))
+                        ev = ', '.join(ev)
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}def {cvar}({ev}):"))
+                        vars['indent'] += single_indent
+                        cvars = []
+                        while rngs['rand_func'].random() > 1 / (new_line_ratio * 2) or len([e for e in cvars if e]) == 0:
+                            cvars.append(add_random_line(vars, will_run))
+                        cvars = [e for e in cvars if e]
+                        ev = []
+                        f = True
+                        while rngs['rand_func'].random() < 1/3 or f:
+                            ev.append(rngs['rand_func'].choice(cvars))
+                            f = False
+                        ev = ', '.join(ev)
+                        if rngs['rand_func'].random() > 1/3:
+                            vars['added_lines'].append((i, f"{' ' * vars['indent']}return {ev}"))
+                        vars['indent'] -= single_indent
+                        return cvar
+
+                    def rand_call_func(vars, will_run=True):
+                        if (not vars['fun']) or will_run:
+                            add_random_line(vars, will_run)
+                            return
+                        func = rngs['rand_call_func'].choice(vars['fun'])
+                        ev = []
+                        while rngs['rand_call_func'].random() < 1/3:
+                            ev.append(rngs['rand_call_func'].choice(vars['all']))
+                        ev = ', '.join(ev)
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{func}({ev})"))
+
+                    def rand_num_add(vars, will_run=True):  # var (new/old) to random int + random int
+                        cvar = gen_num_var(vars)
+                        pos1 = rngs['rand_num_add'].choice(number_tokens)
+                        pos2 = rngs['rand_num_add'].choice(number_tokens)
+                        falsy = False
+                        chz = rngs['rand_var_add'].randint(1, 3)
+                        match chz:
+                            case 1:
+                                pos3 = '+'
+                                if not (int(pos1) + int(pos2)): falsy = True
+                            case 2:
+                                pos3 = '-'
+                                if not (int(pos1) - int(pos2)): falsy = True
+                            case 3:
+                                pos3 = '*'
+                                if not (int(pos1) * int(pos2)): falsy = True
+
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {pos1} {pos3} {pos2}"))
+                        if falsy:
+                            rand_loop(vars, cvar)
+                        return cvar
+
+                    def rand_var_add(vars, will_run=False):  # var (new/old) to random int + random int
+                        if will_run:
+                            raise Exception('This should not be possible')
+                        cvar = gen_num_var(vars)
 
-        lines = obf.split('\n')
-        for i, line in enumerate(lines):
-            if line.endswith(dno_char):
-                lines[i] = line.replace(dno_char, '')
-            line_char_list = list(lines[i])
-            if line_char_list:
-                while line_char_list[-1] == ' ':
-                    line_char_list.pop()
-                    if not line_char_list:
-                        break
-            lines[i] = ''.join(line_char_list)
-        obf = '\n'.join(lines)
-    return obf
+                        chz = rngs['rand_var_add'].randint(1, 2)
+                        match chz:
+                            case 1:pos1 = rngs['rand_var_add'].choice(number_tokens)
+                            case 2:pos1 = rngs['rand_var_add'].choice(vars['all'])
+
+                        chz = rngs['rand_var_add'].randint(1, 2)
+                        match chz:
+                            case 1:pos2 = rngs['rand_var_add'].choice(number_tokens)
+                            case 2:pos2 = rngs['rand_var_add'].choice(vars['all'])
+
+                        chz = rngs['rand_var_add'].randint(1, 7)
+                        match chz:
+                            case 1:pos3 = '+'
+                            case 2:pos3 = '-'
+                            case 3:pos3 = '/'
+                            case 4:pos3 = '//'
+                            case 5:pos3 = '%'
+                            case 6:pos3 = '*'
+                            case 7:pos3 = '**'
+
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {pos1} {pos3} {pos2}"))
+                        return cvar
+
+                    def rand_str(vars, will_run=True):  # var (new/old) to random string
+                        cvar = gen_str_var(vars)  # impossible for this to be falsy
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {create_string()}"))
+                        return cvar
+
+                    def rand_print(vars, will_run=False):  # print 1 random var or 2 random string or 3 random int or 4 random list
+                        if will_run:
+                            raise Exception('This should not be possible')
+                        cvar = gen_str_var(vars)
+                        choice = rngs['rand_print'].randint(1, 4)
+                        match choice:
+                            case 1:
+                                ev = rngs['rand_print'].choice(vars['all'])
+                            case 2:
+                                ev = create_string()
+                            case 3:
+                                ev = rngs['rand_print'].choice(number_tokens)
+                            case 4:
+                                ev = create_list(vars)
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}print({ev})"))
+
+                    def rand_lst(vars, will_run=True):  # var (new/old) to random list
+                        lst = create_list(vars, will_run)
+                        cvar = gen_lst_var(vars)
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}{cvar} = {lst}"))
+                        if lst == '[]':  # this will miss some but vast majority will be caught
+                            rand_loop(vars, cvar)
+                        return cvar
+
+                    def add_pass(vars, will_run=True):  # pass
+                        vars['added_lines'].append((i, f"{' ' * vars['indent']}pass"))
+
+                    run_vars = [rand_num, rand_num_add, rand_str, rand_lst, add_pass, rand_func]
+                    all_vars = run_vars + [rand_var, rand_print, rand_var_add, rand_call_func]
+
+                    def add_random_line(vars, will_run=True):
+                        if will_run:
+                            line_variations = run_vars
+                        else:
+                            line_variations = all_vars
+                        variation = rngs['add_random_line'].choice(line_variations)
+                        cvar = variation(vars, will_run)
+                        return cvar
+
+                    add_random_line(varis)
+
+                prev = line
+
+            varis['added_lines'].reverse()
+            for line in varis['added_lines']:
+                lines.insert(line[0], line[1])
+            obf = '\n'.join(lines)
+
+            lines = obf.split('\n')
+            for i, line in enumerate(lines):
+                if line.endswith(dno_char):
+                    lines[i] = line.replace(dno_char, '')
+                line_char_list = list(lines[i])
+                if line_char_list:
+                    while line_char_list[-1] == ' ':
+                        line_char_list.pop()
+                        if not line_char_list:
+                            break
+                lines[i] = ''.join(line_char_list)
+            obf = '\n'.join(lines)
+        return obf
 
 _CYAN = '\033[96m'
 _RESET = '\033[0m'

{zhmiscellany-6.1.1.dist-info → zhmiscellany-6.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zhmiscellany
-Version: 6.1.1
+Version: 6.1.3
 Summary: A collection of useful/interesting python libraries made by zh.
 Home-page: https://discord.gg/ThBBAuueVJ
 Author: zh
@@ -20,6 +20,7 @@ Requires-Dist: psutil>=0
 Requires-Dist: kthread>=0
 Requires-Dist: pillow>=0
 Requires-Dist: fuzzywuzzy>=0
+Requires-Dist: pyautogui>=0; sys_platform == "linux"
 Requires-Dist: ray>=0; sys_platform == "win32"
 Requires-Dist: pywin32>=0; sys_platform == "win32"
 Requires-Dist: random-header-generator>=0; sys_platform == "win32"

{zhmiscellany-6.1.1.dist-info → zhmiscellany-6.1.3.dist-info}/RECORD

@@ -14,14 +14,14 @@ zhmiscellany/image.py,sha256=qUjxiYpc2VVZp2vwr1vN36O2PVQ7YlMKzhegQ1u4c0M,8198
 zhmiscellany/list.py,sha256=S8Z85bLJEP9lk2JkGpzUcG6kpRB7a-NWDIHMPiF5bKo,1473
 zhmiscellany/macro.py,sha256=kKtKYoHLSnBBHyGl8FlnfMaAoraKKSK023VA-mOezO0,27861
 zhmiscellany/math.py,sha256=btOQTe_GvqP0A7Zz84tmN_c8j1NGe_mKnhmAt40lhLU,2482
-zhmiscellany/misc.py,sha256=i4ZZ4ivfSfzjqXPe0etrK9l9zXk-TK6I9HRtts63YHc,30482
+zhmiscellany/misc.py,sha256=llL3ZHD5pxS4RDKLj3gX0k3NpE2mM5g3JVd0k_RvIUg,31979
 zhmiscellany/netio.py,sha256=VCqlo3ev_iOTTu5sXTZQwsYU0WMbAlOTDRsJ5Dj5-fc,2519
 zhmiscellany/pastebin.py,sha256=TbZ3DqFYXo5qt5d95ugrofYoptlzKkjXUr7VnEqa6ks,6357
 zhmiscellany/pipes.py,sha256=zETvWP4PF-PuSzYwR1UCodY4ftNAgmCChb9DUMofXok,4657
 zhmiscellany/processing.py,sha256=sDKIbzG9TNFyT6yJ4TJL59taG-59_v3CBLekVSLrwgE,10899
 zhmiscellany/rust.py,sha256=znN6DYNoa_p-braTuDZKvUnXX8reWLFu_dG4fv2vLR0,442
 zhmiscellany/string.py,sha256=xyqE6V5YF2nieZDcg5ZrXTIrH2D9oDRbZ5vQGz8rPys,4787
-zhmiscellany-6.1.1.dist-info/METADATA,sha256=Lnwfs_NU-_rNk2bHx9V1eDc6yK_Hdnl3mmVqDWSxSHI,43769
-zhmiscellany-6.1.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-zhmiscellany-6.1.1.dist-info/top_level.txt,sha256=ioDtsrevCI52rTxZntMPljRIBsZs73tD0hI00HektiE,13
-zhmiscellany-6.1.1.dist-info/RECORD,,
+zhmiscellany-6.1.3.dist-info/METADATA,sha256=UQtMiCoWBMenj5AXC81dH8HirK5pTFr3FtiPQeUEMIA,43823
+zhmiscellany-6.1.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+zhmiscellany-6.1.3.dist-info/top_level.txt,sha256=ioDtsrevCI52rTxZntMPljRIBsZs73tD0hI00HektiE,13
+zhmiscellany-6.1.3.dist-info/RECORD,,