<jupyter_start><jupyter_text>Redefinindo funções para simular entradas do usuário e evitar de ficar redigitando toda horaImagine que uma etapa do seu projeto atual é fazer um questionário e depois usar as respostas em outras partes do seu programa.Você cria uma função para fazer o questionário, mas percebe que dá muito trabalho ficar digitando as respostas novamente toda vez que for desenvolver/testar as partes do programa que usam essa sua função.Isso pode ser contornado de várias formas, mas a mais prática deve ser 'auto-redefinir' sua função para que ela rode uma vez, memorize todos os seus inputs e depois passe a simular eles como entradaSe você quiser um outro conjunto de entradas diferentes, basta recrear e 'auto-redefinir' ela novamente<jupyter_code>def fazer_questionario():
    questionario = {
        'nome': 'Informe o seu nome: ',
        'idade': 'Informe sua idade: ',
        'peso': 'Informe o seu peso: ',
        'altura': 'Informe a sua altura: ',
        'nascimento': 'Informe sua data de nascimento: ',
        'cor_vavorita': 'Sua cor favorita é: '
    }

    respostas = {}
    for atr, pergunta in questionario.items():
        respostas[atr] = input(pergunta)
    
    return respostas

fazer_questionario = Dt.auto_redefine(fazer_questionario, input_verbose=True)<jupyter_output><empty_output><jupyter_text>Com isso a função acaba sendo chamada 1 vez logo apos ser definida e todos os inputs do usuário ficam salvos internamente para serem repetidos automaticamente em todas as chamadas seguintes. Se quiser usar um novo conjunto de entradas, basta rodar a célular acima outra vez e informar os novos inputs.<jupyter_code>fazer_questionario()<jupyter_output>Informe o seu nome:  makoto
Informe sua idade:  27
Informe o seu peso:  82
Informe a sua altura:  1.85
Informe sua data de nascimento:  25/06/1994
Sua cor favorita é:  azul<jupyter_text>Outra maneira é já deixar definido no código a sequencia de inputs simulados pelo usuário em vez de rodar o programa uma vez para capturar e salvar as entradas:<jupyter_code>def fazer_questionario():
    questionario = {
        'nome': 'Informe o seu nome: ',
        'idade': 'Informe sua idade: ',
        'peso': 'Informe o seu peso: ',
        'altura': 'Informe a sua altura: ',
        'nascimento': 'Informe sua data de nascimento: ',
        'cor_vavorita': 'Sua cor favorita é: '
    }

    respostas = {}
    for atr, pergunta in questionario.items():
        respostas[atr] = input(pergunta)
    
    return respostas

fazer_questionario = Dt.redefine(fazer_questionario, ('Makoto', '27', '82', '1.85', '25/06/1994', 'azul'), input_verbose=True)
fazer_questionario()
def args_plus_inputs(*args, x, y, z):
    input_1 = int(input("Choose the first number: "))
    input_2 = int(input("Choose the second number: "))
    print(f"Computing {input_1} + {input_2} + {x} + {y} + {z} + {args}")
    return input_1 + input_2 + x + y + z + sum(args)

args_plus_inputs = Dt.auto_redefine(args_plus_inputs, input_verbose=True)
def soma_inputs_e_printa(n=0):
    print("O n informado foi:", n)
    a = int(input("Digite um número: "))
    b = int(input("Digite outro número: "))
    print(a+b+n)

test = Dt(soma_inputs_e_printa, keyboard_inputs=('1','2'), verbose=True)

test.just_run()
Dt.redefine
nova = Dt.redefine(soma_inputs_e_printa,('5','7'))
nova()
nova()
Dt.input_interceptor(soma_inputs_e_printa)
auto_nova = Dt.auto_redefine(soma_inputs_e_printa, input_verbose=True)
auto_nova(75)
def tuplefy(thing:list):
    """
        redefine(fn, keyboard_inputs,input_verbose=False)

        Return a new function that will use the 'keyboard_inputs' tuple\
            as simulated inputs, but will work as fn otherwise

        ex.: call_menu = redefine(call_menu,('lorem ipsum','25','y','n'))

        Parameters
        ----------
            fn: The function that will be copied but will use \
                the simulated inputs
            keyboard_inputs: The inputs that will be simulated

        Returns
        -------
            refedined_fn: Return a fn copy that will always \
                use the 'keyboard_inputs' as input simulation
        """
    return thing if type(thing) is tuple else (thing,)
print(tuplefy.__code__)
print(tuplefy.__doc__)
print(tuplefy.__name__)
print(tuplefy.__annotations__)
def soma_diferente(x):
    y=int(input("Digite um número: "))
    z=int(input("Digite um número: "))
    print("A soma é: ",x+y+z)
    return x+y+z,7
from didatictests import Didatic_test as Dt
test_str = Dt.generate_test(soma_diferente, Dt.parse_args(5), 'teste 1', False, True, False)
test_str
Dt(soma_diferente, Dt.parse_args(5), 'teste 1', ('123', '456'), (584, 7), '', False, True, False).run()
test.run()
test = Dt(soma_diferente, Dt.parse_args(5), 'teste 1', False, True, False)
def print_args(args):
    pos_args = args.get('pos_inputs',())
    key_args = args.get('key_inputs',())
    pos_args_str = str(pos_args).replace('(','').replace(')','')
    key_args_str = ', '.join([f'{key}={value}' for key,value in key_args.items()])
    args_str = ', '.join([pos_args_str,key_args_str]).strip(', ')
    print(f"({args_str})")

print_args(Dt.parse_args({'a':5},[2,3,4],3,x=12,y=5))
1+1
print_args(Dt.parse_args(1,2,3))<jupyter_output>(1, 2, 3)<jupyter_text>----<jupyter_code>from didatictests import Didatic_test as Dt
import builtins

inputs = []
input_fn_backup = builtins.input
builtins.input = Dt.intercepted_input_fn(inputs,True,'[I]: ')

nome = input("Digite o seu nome: ")
idade = input("Digite a sua idade: ")
altura = input("Digite a sua altura: ")
peso = input("Digite o seu peso: ")

print([nome,idade,altura,peso])
print(inputs)
from didatictests import Didatic_test as Dt
import builtins

prints = []
print_fn_backup = builtins.print
builtins.print = Dt.intercepted_print_fn(prints,True,'[P]: ')

print("Digite o seu nome: ")
print("Digite a sua idade: ")
print("Digite a sua altura: ")
print("Digite o seu peso: ")

builtins.print = print_fn_backup

print(prints)
def fn(*args,**kwargs):
    print(args)
    print(kwargs)

fn(1,'a',True,x=0,y=False,z=[])
from didatictests import Didatic_test as Dt

def soma(a,b,c,d,e,jota):
    print('iniciando a função')
    x = int(input("Digite o valor de x"))
    y = int(input("Digite o valor de y"))
    z = int(input("Digite o valor de z"))
    soma = sum([a,b,c,x,y,z])
    print('total:', soma)
    return soma,d,e

interceptions = {}
soma_interceptada = Dt.intercepted_fn(soma, interceptions, True, '[i]: ','[p]: ')
soma_interceptada(1,2,3,d=0,e=-1,jota="aaaaa")
interceptions
from didatictests import Didatic_test

def soma(a,b,c,d=0,e=7):
    print('iniciando a função')
    x = int(input("Digite o valor de x"))
    y = int(input("Digite o valor de y"))
    z = int(input("Digite o valor de z"))
    soma = sum([a,b,c,x,y,z])
    print('total:', soma)
    return soma,d,e

Didatic_test.generate_test(soma,Didatic_test.parse_args(1,2,3,e=5,d=15),"Teste-1",True,True,True,False)
Didatic_test(soma, Didatic_test.parse_args(1, 2, 3, e=5, d=15), 'Teste-1', ['582', '693', '471'], (1752, 15, 5), 'iniciando a função\ntotal: 1752\n', False, True, True).run()<jupyter_output>Case: Teste-1
outputs: ✔️  prints: ✔️                
---------------------------------------------------<jupyter_text>----<jupyter_code>from didatictests import Didatic_test

def soma(a,b,c,d=0,e=7):
    print('iniciando a função')
    x = int(input("Digite o valor de x"))
    y = int(input("Digite o valor de y"))
    z = int(input("Digite o valor de z"))
    soma = sum([a,b,c,x,y,z])
    print('total:', soma)
    return soma,d,e

soma2 = Didatic_test.auto_redefine(soma,Didatic_test.parse_args(1,2,3,e=5,d=15),False)
soma2(1,2,3,d=4,e=5)
soma2(1,2,3,d=4,e=5)<jupyter_output>iniciando a função
total: 18<jupyter_text>---<jupyter_code>from didatictests import Didatic_test

def soma(a,b,c,d=0,e=7):
    print('iniciando a função')
    x = int(input("Digite o valor de x"))
    y = int(input("Digite o valor de y"))
    z = int(input("Digite o valor de z"))
    soma = sum([a,b,c,x,y,z])
    print('total:', soma)
    return soma,d,e

soma2 = Didatic_test.redefine2(soma,['7','8','9'],False)
soma2(1,2,3,d=4,e=5)
soma2(1,2,3,d=4,e=5)<jupyter_output>iniciando a função
total: 30<jupyter_text>-----<jupyter_code>x = ['a','b','c']
x.remove('a')
x<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14792543595911004, 'fraction_numerical': 0.020084185207456404, 'mean_word_length': 4.162011173184357, 'pattern_counts': {'":': 0, '<': 24, '<?xml version=': 0, '>': 24, 'https://': 0, 'lorem ipsum': 1, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '40080', 'license': 'MIT', 'n_tokens_mistral': 3257, 'n_tokens_neox': 3190, 'n_words': 787, 'path': 'notebooks/sandbox.ipynb', 'repo_name': 'lmkawakami/didatictests', 'size': '8315'}