<jupyter_start><jupyter_text>Filters the Java language and returns a list with the name of the projects<jupyter_code>df= dataset.loc[dataset['gh_lang'] == 'java']
list_name = df.gh_project_name.unique().tolist()<jupyter_output><empty_output><jupyter_text>Creates 2 filters for passing and non-passing builds<jupyter_code>passed = df.loc[df['tr_status'] == 'passed']
failed = df.loc[df['tr_status'] == 'failed']

# print('Projetos Java')
# print('Total de builds que passaram {}'.format(passed.size))
# print('Total de builds que NÃO passaram {}'.format(failed.size))<jupyter_output><empty_output><jupyter_text>Creates a list with the amount builds passed and failed<jupyter_code>passed = []
failed = []
for i in range(len(list_name)):
    project = df.loc[df['gh_project_name'] == list_name[i]] 
    _passed = project.loc[project['tr_status'] == 'passed']
    _failed = project.loc[project['tr_status'] == 'failed']
    
    passed.append(_passed.size)
    failed.append(_failed.size)<jupyter_output><empty_output><jupyter_text>Status Build<jupyter_code>def status_build(project_name):
    #filtra o dataset pelo nome do projeto e ordena as datas do dataset
    df = dataset.loc[dataset['gh_project_name'] == project_name]
    
    df = df.sort_values(by='gh_pushed_at', ascending=False)#ordena da data mais atual para mais antiga
    
    df['gh_pushed_at'] = pd.to_datetime(df.gh_pushed_at).dt.date#le a coluna com apenas os dias
    
    date_line = df.gh_pushed_at # cria uma Serie com as datas
    status_build = df.tr_status.tolist() # cria uma lista com os status da build

    
    '''
    cont = 0

    for i in range(len(status_build)):

        if('failed' == status_build[i]):


            print(f'failed: {i} | time: {cont} | {time[i]}')
            cont += 1

        elif('passed' == status_build[i]):

            print(f'passed: {i} | time: {cont} | {time[i]}')
    '''
    
    build_red = []
    sett = 0
    
    for i in range(len(status_build)):

        if("failed" == status_build[i]):
            if(sett == 0):
                index_fail = i
                sett = 1
        if(('passed' == status_build[i]) and (sett == 1)):
                
                #print(f"{project_name} | build: fail:{index_fail} passed:{i} | linha: {i}: days: {date_line.iloc[i]} - {date_line.iloc[index_fail]} | day: {date_line.iloc[index_fail] - date_line.iloc[i]}")
                build_red.append(date_line.iloc[index_fail] - date_line.iloc[i]) # subtrai o dia que a build nao passou ate o dia que passa
                sett = 0

    return(build_red) # retorna uma lista com datas de quando deu fail ate pasar<jupyter_output><empty_output><jupyter_text>Status Build for all projects<jupyter_code>list_name = dataset.gh_project_name.unique().tolist() 

#print(f"quantidade total de projetos {len(list_name)}")

list_days_broken = []
for i in range(len(list_name)):
    list_days_broken.append(status_build(list_name[i]))

days_broken = []
for j in range(len(list_days_broken)):
    days_broken = days_broken + list_days_broken[j]
    


days = pd.DataFrame(days_broken, columns=['date']) # cria uma

#print(days.date.dt.days.describe())


count = 0 
metric = days.date.dt.days.describe()[6] # 3 quartil 

#percorre o vetor quando ele encontra um que é equivalente ao if da break e vai para o proximo vetor que no caso seria outro projeto
for k in range(len(list_days_broken)):
    validate = 0 
    for j in range(len(list_days_broken[k])):
        if(metric <= list_days_broken[k][j].days):
            count+=1
            break
            #se uma metrica está sendo contada mais de uma ves quando ele encontar deve passar pra proxima lista e não fica na mesma 

#print(f"Quantidade de projetos com builds quebradas é de {count} tendo uma duração de {metric} dias")<jupyter_output><empty_output><jupyter_text>Status build for JAVA<jupyter_code>'''
Filtro a linguagem java, utilizo o def status_build e recebo um lista de dias que a build ficou quebrada, adiciono todos elementos em um lista e 
torno ela em uma Serie utilizo o describe para descrever a media e os quartils
pego o 3 quartil como metrica de builds com mais duração em quebra

percorro o vetor com as listas de dias quebrados e verifico quais são iguais ou maior a metrica definida e somo em um contador para cada projeto encontrado
'''
def days_briken(language, )
df = dataset.loc[dataset['gh_lang'] == 'java']

list_name = df.gh_project_name.unique().tolist() 

print(f"quantidade de projetos java {len(list_name)}")

list_days_broken = []
for i in range(len(list_name)):
    list_days_broken.append(status_build(list_name[i]))

days_broken = []
for j in range(len(list_days_broken)):
    days_broken = days_broken + list_days_broken[j]
    


days_java = pd.DataFrame(days_broken, columns=['date']) # cria uma


print(days_java.date.dt.days.describe())

metric = days_java.date.dt.days.describe()[6] # 3 quartil



count = 0 
metric = days_java.date.dt.days.describe()[6] # 3 quartil 

#percorre o vetor quando ele encontra um que é equivalente ao if da break e vai para o proximo vetor que no caso seria outro projeto
for k in range(len(list_days_broken)):
    for j in range(len(list_days_broken[k])):
        if(metric <= list_days_broken[k][j].days):
            count+=1
            break
            #uma metrica está sendo contada mais de uma ves quando ele encontar deve passar pra proxima lista e não fica na mesma 

#print(f"Quantidade de projetos java com builds quebradas é de {count} tendo uma duração de {metric} dias")<jupyter_output><empty_output><jupyter_text>Status build for RUBY<jupyter_code>'''
I filter the java language, I use the def status_build and I get a list of days that the build was broken, I add all the elements in a list and
I use it to describe the media and the quartiles
I get the 3 quartile as the metric of builds with more duration in break

I run the vector with the lists of broken days and check which are equal or greater the defined metrica and somo in a counter for each project found
'''

df = dataset.loc[dataset['gh_lang'] == 'ruby']

list_name = df.gh_project_name.unique().tolist() 

#print(f"quantidade de projetos java {len(list_name)}")

list_days_broken = []
for i in range(len(list_name)):
    list_days_broken.append(status_build(list_name[i]))

days_broken_ruby = []
for j in range(len(list_days_broken)):
    days_broken_ruby = days_broken_ruby + list_days_broken[j]
    


days_ruby = pd.DataFrame(days_broken_ruby, columns=['date']) # cria uma


#print(days_ruby.date.dt.days.describe())

metric = days_ruby.date.dt.days.describe()[6] # 3 quartil



count = 0 
metric = days_ruby.date.dt.days.describe()[6] # 3 quartil 

#percorre o vetor quando ele encontra um que é equivalente ao if da break e vai para o proximo vetor que no caso seria outro projeto
for k in range(len(list_days_broken)):
    for j in range(len(list_days_broken[k])):
        if(metric <= list_days_broken[k][j].days):
            count+=1
            break
            #uma metrica está sendo contada mais de uma ves quando ele encontar deve passar pra proxima lista e não fica na mesma 

#print(f"Quantidade de projetos ruby com builds quebradas é de {count} tendo uma duração de {metric} dias")<jupyter_output><empty_output><jupyter_text>Number of projects<jupyter_code>def quantidade_projetos(language, sett):
    small, medium, large, very_small= [], [], [], []
    
    df = dataset.sort_values(['gh_sloc'], ascending=False)
    df = df.loc[df['gh_lang'] == language]
    
    list_name_project = df.gh_project_name.unique().tolist()

    if(sett == 1):
        for name in list_name_project:
            df0 = df.loc[df['gh_project_name'] == name]
            if(1000 > df0.gh_sloc[0:1].item()):
                very_small.append(name)
        return(very_small)
       
    if(sett == 2):
        for name in list_name_project:
            df1 = df.loc[df['gh_project_name'] == name]
            if((1000 < df1.gh_sloc[0:1].item()) and (10000 > df1.gh_sloc[0:1].item())):
                small.append(name)
        return(small)
    
    if(sett == 3):
        for name in list_name_project:
            df2 = df.loc[df['gh_project_name'] == name]
            if((10000 < df2.gh_sloc[0:1].item()) and (100000 > df2.gh_sloc[0:1].item())):
                medium.append(name)
        return(medium)
    
    if(sett == 4):
        for name in list_name_project:
            df3 = df.loc[df['gh_project_name'] == name]
            if(100000 < df3.gh_sloc[0:1].item()):
                large.append(name)
        return(large)<jupyter_output><empty_output><jupyter_text>Number of projects with broken build<jupyter_code>def days_broken(list_name):
    
    print(f"quantidade de projetos {len(list_name)}")


    list_days_broken = []
    for i in range(len(list_name)): #cria uma matriz de dias quebrados
        list_days_broken.append(status_build(list_name[i]))

    days_broken = []
    for j in range(len(list_days_broken)): #transforma a matriz numa lista
        days_broken = days_broken + list_days_broken[j]



    df_broken = pd.DataFrame(days_broken, columns=['date']) # cria uma


    print(df_broken.date.dt.days.describe())

    metric = df_broken.date.dt.days.describe()[6] # 3 quartil



    count = 0 
    metric = df_broken.date.dt.days.describe()[6] # 3 quartil 

    #percorre o vetor quando ele encontra um que é equivalente ao if da break e vai para o proximo vetor que no caso seria outro projeto
    for k in range(len(list_days_broken)):
        for j in range(len(list_days_broken[k])):
            if(metric <= list_days_broken[k][j].days):
                count+=1
                break
                #uma metrica está sendo contada mais de uma ves quando ele encontar deve passar pra proxima lista e não fica na mesma 

    #print(f"Quantidade de projetos com builds quebradas é de {count} tendo uma duração de {metric} dias")
   
    return(df_broken.date.dt.days)<jupyter_output><empty_output><jupyter_text>Displays build broken by language<jupyter_code>list_very_small = quantidade_projetos('java', 1) 
very_small = days_broken(list_very_small)

list_small = quantidade_projetos('java', 2) 
small = days_broken(list_small)

list_medium = quantidade_projetos('java', 3) 
medium = days_broken(list_medium)

list_large = quantidade_projetos('java', 4) 
large = days_broken(list_large)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11218288801003183, 'fraction_numerical': 0.008970772643966432, 'mean_word_length': 3.6347787215020118, 'pattern_counts': {'":': 0, '<': 48, '<?xml version=': 0, '>': 44, 'https://': 0, 'lorem ipsum': 0, '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': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '209863', 'license': 'MIT', 'n_tokens_mistral': 3701, 'n_tokens_neox': 3478, 'n_words': 952, 'path': 'src/RQ3.ipynb', 'repo_name': 'wagnerfns/CI-analysis', 'size': '10367'}