# print model results
def model_results(model, test_data, test_lebel):
    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd
    from tabulate import tabulate
    from sklearn import metrics

    table = pd.DataFrame(columns=["metrika", "uspješnost"])
    print('Uspješnost modela:')

    proba           = model.predict_proba(test_data)
    predicted_label = np.asarray(model.predict(test_data))

    table.loc[0]  = ["logloss"] + [metrics.log_loss(test_lebel, proba)]
    table.loc[1]  = ["accuracy_test"] + [metrics.accuracy_score(test_lebel, predicted_label)]
    table.loc[2]  = ["F1_test"] + [metrics.f1_score(test_lebel, predicted_label,average='weighted')]
    table.loc[3]  = ["precision_test"] + [metrics.precision_score(test_lebel, predicted_label, average='weighted')]
    table.loc[4]  = ["auc_test_ovr"] + [metrics.roc_auc_score(test_lebel, proba, multi_class="ovr",average='weighted')]
    table.loc[5]  = ["auc_test_ovo"] + [metrics.roc_auc_score(test_lebel, proba, multi_class="ovo",average='weighted')]
    table.loc[6]  = ["r2_test"] + [metrics.r2_score(test_lebel.astype(int), predicted_label.astype(int))]

    return table

# plot feature importance
def plot_feature_importance(model, feature_columns):
    import matplotlib.pyplot as plt
    import numpy as np

    feature_importance = model.feature_importances_
    feature_importance = 100.0 * (feature_importance / feature_importance.max())
    y_pos  = np.arange(feature_importance.shape[0]) + .5
    fig, ax = plt.subplots()
    f = fig
    fig.set_size_inches(18.5, 10.5, forward=True)
    ax.barh(y_pos,
            feature_importance,
            align='center',
            color='green',
            ecolor='black',
            height=0.5)
    ax.set_yticks(y_pos)
    ax.set_yticklabels(feature_columns)
    ax.invert_yaxis()
    ax.set_xlabel('Relativna važnost značajki')
    ax.set_title('Važnost značajki')
    plt.show()

# plot feature importance
def plot_feature_importance2(model, number_of_features_to_use, feature_importances ):
    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd

    # convert arrays to dataframes
    df = pd.DataFrame( [feature_importances["feature_name"].values[:number_of_features_to_use].ravel(), model.feature_importances_.ravel()])
    df = df.T
    df.columns = ["names", "importances"]
    df = df.sort_values(by=["importances"], ascending=False)

    feature_importance = df.iloc[:,1].values[:50].ravel()
    feature_importance = 100.0 * (feature_importance / feature_importance.max())
    y_pos  = np.arange(feature_importance.shape[0]) + .5
    fig, ax = plt.subplots()
    f = fig
    fig.set_size_inches(18.5, 10.5, forward=True)
    ax.barh(y_pos,
            feature_importance,
            align='center',
            color='green',
            ecolor='black',
            height=0.5)
    ax.set_yticks(y_pos)
    ax.set_yticklabels(df.iloc[:,0].values[:100].ravel())
    ax.invert_yaxis()
    ax.set_xlabel('Relativna važnost značajki')
    ax.set_title('Važnost značajki')
    plt.show()

# plot fancy confusion matrix
def make_and_plot_confusion_matrix(test_lebel, best_preds):
    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd
    import matplotlib.cm as cm
    from sklearn.metrics import confusion_matrix

    malware_dict = { 1 : 'Ramnit', 2 : 'Lollipop', 3 : 'Kelihos_ver3', 4 : 'Vundo', 5 : 'Simba',
                 6 : 'Tracur', 7 : 'Kelihos_ver1', 8 : 'Obfuscator.ACY', 9 : 'Gatak'}

    names = list(malware_dict.values())
    cm = confusion_matrix(test_lebel, best_preds)
    cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

    norm_conf = []
    for i in cm:
        a = 0
        tmp_arr = []
        a = sum(i, 0)
        for j in i:
            tmp_arr.append(float(j)/float(a))
        norm_conf.append(tmp_arr)

    fig = plt.figure(figsize=(10, 10))
    plt.clf()
    ax = fig.add_subplot(111)
    ax.set_aspect(1)

    res = ax.imshow(np.array(norm_conf), cmap=plt.cm.Blues, interpolation='nearest')

    width = len(cm)
    height = len(cm[0])

    for x in range(width):
        for y in range(height):
            ax.annotate(str(format(round(cm[x][y], 2))), xy=(y, x), horizontalalignment='center', verticalalignment='center')
    plt.title('Konfuzijska matrica')
    cb = fig.colorbar(res)
    plt.xticks(range(width), names)
    plt.yticks(range(height), names)
    plt.grid(False)

# plot learning curves
def plot_learning_curve( model, X_train, y_train, X_test, y_test, cv, seed ):

    import warnings
    warnings.filterwarnings("ignore")

    # load libraries
    import numpy as np
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split as tts
    from sklearn.metrics import accuracy_score, make_scorer, log_loss

    import matplotlib.pyplot as plt
    from sklearn.model_selection import learning_curve, StratifiedKFold

    #plt.style.use('ggplot')
    malware_dict = { 1 : 'Ramnit', 2 : 'Lollipop', 3 : 'Kelihos_ver3', 4 : 'Vundo', 5 : 'Simba',
                     6 : 'Tracur', 7 : 'Kelihos_ver1', 8 : 'Obfuscator.ACY', 9 : 'Gatak'}

    # Create CV training and test scores for various training set sizes
    train_sizes, train_scores, test_scores = learning_curve(model,
                                               X_train, y_train, cv=StratifiedKFold(n_splits=cv),
                                               scoring="accuracy",
                                               #scoring=make_scorer(log_loss, needs_proba=True, labels=list(malware_dict.keys())),
                                               n_jobs=-1,
                                               random_state=seed)

    # Create means and standard deviations of training set scores
    train_mean = np.mean(train_scores, axis=1)
    train_std = np.std(train_scores, axis=1)

    # Create means and standard deviations of test set scores
    test_mean = np.mean(test_scores, axis=1)
    test_std = np.std(test_scores, axis=1)

    # Draw lines
    plt.subplots(1, figsize=(12,12))
    plt.plot(train_sizes, train_mean, '--', color="#111111",  label="Uspješnost treniranja")
    plt.plot(train_sizes, test_mean, color="#111111", label="Uspješnost unakrsne validacije")

    # Draw bands
    plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color="#DDDDDD")
    plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color="#DDDDDD")

    # Create plot
    plt.title("Krivulja učenja")
    plt.xlabel("Veličina skupa za treniranje"), plt.ylabel("Točnost"), plt.legend(loc="best")
    plt.tight_layout(); plt.show()

    # make predictions for test data
    y_pred = model.predict(X_test)
    predictions = [round(value) for value in y_pred]

    # evaluate predictions
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy: %.2f%%" % (accuracy * 100.0))

    # retrieve performance metrics
    results = model.evals_result()
    epochs = len(results['validation_0']['merror'])
    x_axis = range(0, epochs)

    # plot log loss
    fig, ax = plt.subplots(figsize=(12,12))
    ax.plot(x_axis, results['validation_0']['mlogloss'], label='Train')
    ax.plot(x_axis, results['validation_1']['mlogloss'], label='Test')
    ax.legend()
    plt.ylabel('Log Loss')
    plt.title('XGBoost Log Loss')
    plt.show()

    # plot classification error
    fig, ax = plt.subplots(figsize=(12,12))
    ax.plot(x_axis, results['validation_0']['merror'], label='Train')
    ax.plot(x_axis, results['validation_1']['merror'], label='Test')
    ax.legend()
    plt.ylabel('Pogreška klasifikacije')
    plt.title('XGBoost pogreška klasifikacije')
    plt.show()

# make submission file
def make_submisson_file( md5_hash, predictions ):
    import pandas as pd
    name = input("Ime za submisson file? ")

    result = pd.concat([md5_hash, pd.DataFrame(predictions)], axis=1, sort=False)
    result.columns = ['Id','Prediction1','Prediction2','Prediction3','Prediction4','Prediction5','Prediction6','Prediction7','Prediction8', 'Prediction9']
    filename = '../dataset/submissioni/submisson_' + name + '.csv'
    result.to_csv(filename, index=False)

    return result

# distribution of malware-s over classes
def draw_malware_distribution_over_classes(classes):
    import matplotlib.pyplot as plt

    features_class_quantity = { }
    features_class_precentage = []

    malware_dict = { 1 : 'Ramnit', 2 : 'Lollipop', 3 : 'Kelihos_ver3', 4 : 'Vundo', 5 : 'Simba',
                 6 : 'Tracur', 7 : 'Kelihos_ver1', 8 : 'Obfuscator.ACY', 9 : 'Gatak'}

    for i in range(1,10):
        features_class_quantity[i] = sum( classes == i)
        features_class_precentage.append(sum(classes == i)/len(classes) * 100)

    quantity = list(features_class_quantity.values())
    print("Broj malwarea po klasama:")
    print(features_class_quantity.values())
    print("Postotci malware-aa po klasama:")
    print(features_class_precentage)

    fig, ax = plt.subplots(figsize=(15,7))
    ax.bar(list(malware_dict.values()), quantity, color = ['Salmon', 'lightblue', 'lightgreen', 'yellow', 'pink', 'cyan', 'plum', 'peachpuff', 'khaki'])
    plt.xticks(rotation='vertical')
    plt.xlabel('Klase malware-a', fontweight='bold')
    plt.ylabel('Količina', fontweight='bold')

    plt.show()

# show best (default 3) parameters and return them in a list
def report(results, n_top=3):
    import pandas as pd
    import numpy as np

    params = []
    for i in range(1, n_top + 1):
        candidates = np.flatnonzero(results['rank_test_score'] == i)
        for candidate in candidates:
            print("Model ranga: {0}".format(i))
            print("Mean validation score: {0:.5f} (std: {1:.5f})".format(
                  results['mean_test_score'][candidate],
                  results['std_test_score'][candidate]))
            print("Parametri: {0}".format(results['params'][candidate]))
            print("")
            params.append(results['params'][candidate])
    return params

# make or load basic model
def XGBClassifier_load_or_make(X_train, y_train, X_test, y_test, n_estimators=1000, early_stopping_rounds=20, eval_metric=["merror", "mlogloss"]):
    import xgboost as xgb
    from xgboost import XGBClassifier
    import pickle
    import numpy as np

    eval_set = [(X_train, y_train), (X_test, y_test)]

    load_or_make = input("Load or make XGBClassifier? ")

    if load_or_make == "make":
        # for saving
        name = input("Ime za XGBClassifier? ")
        filename = 'data/model_xgb_' + name + '.sav'

        basic_model_xgb = xgb.XGBClassifier(n_estimators=n_estimators, n_jobs=-1)
        basic_model_xgb.fit(X_train, y_train, early_stopping_rounds=early_stopping_rounds, eval_metric=eval_metric, eval_set=eval_set, verbose=True)

        # save
        pickle.dump(basic_model_xgb, open(filename, 'wb'))
        print('XGBClassifier je spremljen u: ' + filename )
        return basic_model_xgb

    elif load_or_make == "load":
        # pick model
        print('Izaberi XGBClassifier:')
        print('1. basic_model_xgb')
        print('2. basic_one_gram')
        #print('3. basic_metadata_bytes.sav')
        print('4. basic_entropy')
        print('5. basic_image')
        print('6. basic_string_len')
        print('7. basic_metadata_asm')
        print('8. basic_symbols')
        print('9. basic_opcode')
        print('10. basic_reg')
        print('11. basic_section')
        print('12. basic_dd')
        print('13. basic_api')
        print('14. basic_keywords')
        print('15. all_features')

        option = input()
        if option == '1':
            filename = '../dataset/basic_model/basic_model_xgb.sav'
        elif option == '2':
            filename = '../dataset/basic_model/model_xgb_one_gram.sav'
        #elif option == '3':
        #    filename = '../../dataset/basic_model/model_xgb_one_gram.sav'
        elif option == '4':
            filename = '../dataset/basic_model/model_xgb_entropija_80_20.sav'
        elif option == '5':
            filename = '../dataset/basic_model/model_xgb_image_80_20.sav'
        elif option == '6':
            filename = '../dataset/basic_model/model_xgb_string_length_features_80_20.sav'
        elif option == '7':
            filename = '../dataset/basic_model/model_xgb_metadata_asm_features.sav'
        elif option == '8':
            filename = '../dataset/basic_model/model_xgb_symbols_features.sav'
        elif option == '9':
            filename = '../dataset/basic_model/model_xgb_opcode_features.sav'
        elif option == '10':
            filename = '../dataset/basic_model/model_xgb_reg_features.sav'
        elif option == '11':
            filename = '../dataset/basic_model/model_xgb_section_features_80_20.sav'
        elif option == '12':
            filename = '../dataset/basic_model/model_xgb_dd_features.sav'
        elif option == '13':
            filename = '../dataset/basic_model/model_xgb_apis.sav'
        elif option == '14':
            filename = '../dataset/basic_model/model_xgb_key_features.sav'
        elif option == '15':
            filename = '../dataset/basic_model/model_xgb_svi_featuri.sav'
        else:
            print('Ne postoji zatražena opcija!')
            raise ValueError('Ne postoji zatražena opcija - pri učitavanju XGBClassifiera!')
            return

        basic_model_xgb = pickle.load(open(filename, 'rb'))
        basic_model_xgb.get_params()

        return basic_model_xgb

    else:
        print("Krivi unos! Upiši 'load' ili 'make'!")
        raise ValueError('Nije upisano load ili make - pri učitavanju/izradi XGBClassifiera!')
        return

#newer xgboost version
def XGBClassifier_newer_load_or_make(X_train, y_train, X_test, y_test, n_estimators=1000, early_stopping_rounds=20, eval_metric=["merror", "mlogloss"]):
    import xgboost as xgb
    from xgboost import XGBClassifier
    import pickle
    import numpy as np

    eval_set = [(X_train, y_train), (X_test, y_test)]

    load_or_make = input("Load or make XGBClassifier? ")

    if load_or_make == "make":
        # for saving
        name = input("Ime za XGBClassifier? ")
        filename = '../dataset/basic_model/model_xgb_' + name + '.sav'

        basic_model_xgb = xgb.XGBClassifier(n_estimators=n_estimators, n_jobs=-1)
        basic_model_xgb.fit(X_train, y_train, early_stopping_rounds=early_stopping_rounds, eval_metric=eval_metric, eval_set=eval_set, verbose=True)

        # save
        print('XGBClassifier je spremljen u: ' + filename )
        basic_model_xgb.save_model(filename)
        return basic_model_xgb

    elif load_or_make == "load":
        # pick model
        print('Izaberi XGBClassifier:')
        print('1. basic_model_xgb')
        print('2. basic_one_gram')
        #print('3. basic_metadata_bytes.sav')
        print('4. basic_entropy')
        print('5. basic_image')
        print('6. basic_string_len')
        print('7. basic_metadata_asm')
        print('8. basic_symbols')
        print('9. basic_opcode')
        print('10. basic_reg')
        print('11. basic_section')
        print('12. basic_dd')
        print('13. basic_api')
        print('14. basic_keywords')
        print('15. all_features')

        option = input()
        if option == '1':
            filename = '../dataset/basic_model/basic_model_xgb.sav'
        elif option == '2':
            filename = '../dataset/basic_model/model_xgb_one_gram.sav'
        #elif option == '3':
        #    filename = '../../dataset/basic_model/model_xgb_one_gram.sav'
        elif option == '4':
            filename = '../dataset/basic_model/model_xgb_entropija_80_20.sav'
        elif option == '5':
            filename = '../dataset/basic_model/model_xgb_image_80_20.sav'
        elif option == '6':
            filename = '../dataset/basic_model/model_xgb_string_length_features_80_20.sav'
        elif option == '7':
            filename = '../dataset/basic_model/model_xgb_metadata_asm_features.sav'
        elif option == '8':
            filename = '../dataset/basic_model/model_xgb_symbols_features.sav'
        elif option == '9':
            filename = '../dataset/basic_model/model_xgb_opcode_features.sav'
        elif option == '10':
            filename = '../dataset/basic_model/model_xgb_reg_features.sav'
        elif option == '11':
            filename = '../dataset/basic_model/model_xgb_section_features_80_20.sav'
        elif option == '12':
            filename = '../dataset/basic_model/model_xgb_dd_features.sav'
        elif option == '13':
            filename = '../dataset/basic_model/model_xgb_apis.sav'
        elif option == '14':
            filename = '../dataset/basic_model/model_xgb_key_features.sav'
        elif option == '15':
            filename = '../dataset/basic_model/model_xgb_svi_featuri.sav'
        else:
            print('Ne postoji zatražena opcija!')
            raise ValueError('Ne postoji zatražena opcija - pri učitavanju XGBClassifiera!')
            return

        basic_model_xgb = pickle.load(open(filename, 'rb'))
        basic_model_xgb.get_params()

        return basic_model_xgb

    else:
        print("Krivi unos! Upiši 'load' ili 'make'!")
        raise ValueError('Nije upisano load ili make - pri učitavanju/izradi XGBClassifiera!')
        return

# randomly search for hyperparameters
def RandomizedSearchCV_load_or_make(model, data, labels, random_grid, cv="5", scoring="accuracy", n_iter=20, random_state=47):
    import xgboost as xgb
    from xgboost import XGBClassifier
    from sklearn.model_selection import RandomizedSearchCV
    import pickle
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold

    # we use the RandomizedSearchCV to find the best parameters for our XGB model

    load_or_make = input("Load or make RandomizedSearchCV?")
    if load_or_make == "load":

        # pick RandomizedSearchCV to load
        print('Izaberi RandomizedSearchCV:')
        print('1. RandomizedSearchCV10_basic_all_features_neg_log_loss ')

        option = input()
        if option == '1':
            filename = '.../dataset/basic_modeli/RandomizedSearchCV10_basic_all_features_neg_log_loss.sav'
        else:
            print('Ne postoji zatražena opcija!')
            raise ValueError('Ne postoji zatražena opcija - pri učitavanju RandomizedSearchCV!')
            return

        rand_XGB = pickle.load(open(filename, 'rb'))
        rand_XGB.get_params()

        # show results
        rand_XGB_results_df = pd.DataFrame(rand_XGB.cv_results_)[['mean_test_score', 'std_test_score', 'params','rank_test_score']]
        rand_XGB_results_df

        # plot of randomized search results
        rand_XGB_mean_scores = rand_XGB.cv_results_['mean_test_score']
        plt.plot(list(range(1, 21)), rand_XGB_mean_scores)
        plt.xlabel('k-ti Model Randomized Search CV treniranja (XGB)')
        plt.ylabel('Točnost unakrsne validacije')

        return [rand_XGB, rand_XGB_results_df]

    elif load_or_make == "make":
        # getting ready for saving later
        name = input('Unesi ime novo-pokrenutoga RandomizedSearchCV? ')
        filename = 'data/RandomizedSearchCV_' + name + '.sav'

        model_XGB = model
        # RandomizedSearchCV
        rand_XGB = RandomizedSearchCV(model_XGB,
                                      param_distributions = random_grid,
                                      cv=StratifiedKFold(n_splits=cv),
                                      scoring=scoring,
                                      n_iter=20,
                                      random_state=random_state,
                                      return_train_score=False,
                                      verbose=True,
                                      n_jobs=-1)
        # fit
        rand_XGB.fit(data, labels)

        # save
        pickle.dump(rand_XGB, open(filename, 'wb'))
        print('RandomizedSearchCV je spremljen u: ' + filename )

        # show results
        rand_XGB_results_df = pd.DataFrame(rand_XGB.cv_results_)[['mean_test_score', 'std_test_score', 'params', 'rank_test_score']]
        rand_XGB_results_df

        # plot of randomized search results
        rand_XGB_mean_scores = rand_XGB.cv_results_['mean_test_score']
        plt.plot(list(range(1, 21)), rand_XGB_mean_scores)
        plt.xlabel('k-ti Model Randomized Search CV treniranja (XGB)')
        plt.ylabel('Točnost unakrsne validacije')

        return [rand_XGB, rand_XGB_results_df]

    else:
        print("Krivi unos! Upiši 'load' ili 'make'!")
        raise ValueError('Nije upisano load ili make - pri učitavanju/izradi RandomizedSearchCV!')
        return

# make model with specific parameters
def XGBClassifier_with_params(grid_or_random_search, X_train, y_train, X_test, y_test, early_stopping_rounds=20, eval_metric=["merror", "mlogloss"]):
    import xgboost as xgb
    from xgboost import XGBClassifier
    import pickle
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt

    # we use the RandomizedSearchCV to find the best parameters for our XGB model
    eval_set = [(X_train, y_train), (X_test, y_test)]

    load_or_make = input("Load or make XGBClassifier?")

    if load_or_make == "load":
        print("Još nema opcija.")
        raise ValueError('Još uvijek nema opcija - pri učitavanju XGBClassifier_with_params!')
        return

    elif load_or_make == "make":
        name = input('Unesi ime novo-pokrenutoga XGBClassifiera? ')
        filename = 'data/XGBClassifier_' + name + '.sav'

        # making a model of best parameters
        param_tuning_xgb = XGBClassifier(reg_lambda        = grid_or_random_search.best_params_['reg_lambda'],
                                         reg_alpha         = grid_or_random_search.best_params_['reg_alpha'],
                                         n_estimators      = grid_or_random_search.best_params_['n_estimators'],
                                         min_samples_split = grid_or_random_search.best_params_['min_samples_split'],
                                         min_samples_leaf  = grid_or_random_search.best_params_['min_samples_leaf'],
                                         max_features      = grid_or_random_search.best_params_['max_features'],
                                         max_depth         = grid_or_random_search.best_params_['max_depth'],
                                         learning_rate     = grid_or_random_search.best_params_['learning_rate'],
                                         gamma             = grid_or_random_search.best_params_['gamma'],
                                         bootstrap         = grid_or_random_search.best_params_['bootstrap'])

        # fit
        param_tuning_xgb.fit(X_train=X_train, y_train=y_train, early_stopping_rounds=early_stopping_rounds, eval_metric=eval_metric, eval_set=eval_set, verbose=True)

        # save
        pickle.dump(param_tuning_xgb, open(filename, 'wb'))
        print("XGBClassifier je spremljen u: " + filename )

        # show results
        param_tuning_xgb_results_df = model_results(param_tuning_xgb, X_test, y_test)
        param_tuning_xgb_results_df

        return [param_tuning_xgb, param_tuning_xgb_results_df]

    else:
        print("Krivi unos! Upiši 'load' ili 'make'!")
        raise ValueError('Nije upisano load ili make - pri učitavanju/izradi XGBClassifier_with_params!')
        return

#grid search in space of given parameters
def GridSearchCV_load_or_make(model, param_grid, data, labels, cv=5):
    import xgboost as xgb
    from xgboost import XGBClassifier
    import pickle
    from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt

    # we use the GridSearchCV to find even better parameters for our XGB model
    load_or_make = input("Load or make GridSearchCV?")

    if load_or_make == "load":
        print("Još nema opcija.")
        raise ValueError('Nije upisano load ili make - pri učitavanju GridSearchCV_load_or_make!')
        return

    elif load_or_make == "make":
        m_XGB = XGBClassifier()

        name = input("Ime za novi GridSearchCV? ")
        filename = 'data/GridSearchCV_' + name + '.sav'

        # grid search
        grid_search = GridSearchCV(m_XGB, param_grid=param_grid, cv=cv, verbose=2, n_jobs=-1)
        grid_search.fit(data, labels)

        # save
        pickle.dump(grid_search, open(filename, 'wb'))
        print("GridSearchCV je spremljen u: " + filename )

        # show results
        grid_search_results_df = pd.DataFrame(grid_search.cv_results_)[['mean_test_score', 'std_test_score', 'params', 'rank_test_score']]
        grid_search_results_df

        # plot of randomized search results
        grid_search_mean_scores = grid_search.cv_results_['mean_test_score']
        plt.plot(list(range(1, 21)), grid_search_mean_scores)
        plt.xlabel('k-ti Model Randomized Search CV treniranja (XGB)')
        plt.ylabel('Točnost unakrsne validacije')

        return [grid_search, grid_search_results_df]

    else:
        print("Krivi unos! Upiši 'load' ili 'make'!")
        raise ValueError('Nije upisano load ili make - pri učitavanju GridSearchCV_load_or_make!')
        return

# distribution of malware-s over classes
def draw_malware_distribution_over_classes(classes):
    import matplotlib.pyplot as plt

    features_class_quantity = { }
    features_class_precentage = []

    malware_dict = { 1 : 'Ramnit', 2 : 'Lollipop', 3 : 'Kelihos_ver3', 4 : 'Vundo', 5 : 'Simba',
                 6 : 'Tracur', 7 : 'Kelihos_ver1', 8 : 'Obfuscator.ACY', 9 : 'Gatak'}

    for i in range(1,10):
        features_class_quantity[i] = sum( classes == i)
        features_class_precentage.append(sum(classes == i)/len(classes) * 100)

    quantity = list(features_class_quantity.values())
    print("Broj malwarea po klasama:")
    print(features_class_quantity.values())
    print("Postotci malware-aa po klasama:")
    print(features_class_precentage)

    fig, ax = plt.subplots(figsize=(15,7))
    ax.bar(list(malware_dict.values()), quantity, color = ['Salmon', 'lightblue', 'lightgreen', 'yellow', 'pink', 'cyan', 'plum', 'peachpuff', 'khaki'])
    plt.xticks(rotation='vertical')
    plt.xlabel('Klase malware-a', fontweight='bold')
    plt.ylabel('Količina', fontweight='bold')

    plt.show()

def compare_malware_distribution_over_classes(classes):
    import matplotlib.pyplot as plt
    import pandas as pd

    features_class_quantity = { }
    features_class_precentage = []

    malware_dict = { 1 : 'Ramnit', 2 : 'Lollipop', 3 : 'Kelihos_ver3', 4 : 'Vundo', 5 : 'Simba',
                 6 : 'Tracur', 7 : 'Kelihos_ver1', 8 : 'Obfuscator.ACY', 9 : 'Gatak'}
    features_train = pd.read_csv("https://raw.githubusercontent.com/mateastanisic/lfs/master/merged_all_features.csv")

    classes_begining_and_end_in_features = { }
    last = 0

    for i in range(1,10):
        classes_begining_and_end_in_features[i] = [last, last + len(features_train.loc[features_train.Class == i]) - 1]
        last = last + len(features_train.loc[features_train.Class == i])

    features_class_quantity_original = { }

    for i in range(1,10):
        features_class_quantity_original[i] = classes_begining_and_end_in_features[i][1] - classes_begining_and_end_in_features[i][0]
        features_class_quantity[i] = sum( classes == i)

    classes_original = list(malware_dict.values())
    quantity_original = list(features_class_quantity_original.values())
    quantity_test = list(features_class_quantity.values())

    listaa = [ classes_original, quantity_original, quantity_test ]
    df = pd.DataFrame()
    df['Classes'] = classes_original
    df['Original'] = quantity_original
    df['Test'] = quantity_test
    df.set_index("Classes", inplace = True)

    df.plot( kind="bar", figsize=( 15,5 ), color=['lightskyblue', 'darkblue'], title = "Distribucija malwarea po klasama",
            rot=1 ).title.set_size( 15 )
    plt.ylabel( "Malware quantity", fontsize = 10 )
    plt.show()


import numpy as np
import tensorflow as tf

"""
Implement pyramid operations as explained in Section 5.2 of our paper, and introduced in:
    Barron and Malik, "Shape, illumination, and reflectance from shading", TPAMI, 2015.
"""

def kernels(mult=1.4):
    """
    Create binomial kernels.

    Inputs
    ------
    mult       Sum of each binomial kernel. See paper for explanation.

    Outputs
    -------
    h_kernel   Horizontal binomial kernel of shape [5, 1, 1, 1] and sum mult.
    w_kernel   Vertical binomial kernel of shape [1, 5, 1, 1] and sum mult.
    """
    h_kernel = mult * np.array([0.0625, 0.25, 0.3750, 0.25, 0.0625], dtype=np.float32)
    w_kernel = mult * np.array([0.0625, 0.25, 0.3750, 0.25, 0.0625], dtype=np.float32)

    return h_kernel[:, np.newaxis], w_kernel[np.newaxis, :]

def downsample(img):
    """
    Downsample an image by a factor of 2 using a binomial 5-tap filter (multiplied by a factor mult) as AA filter.

    Inputs
    ------
    img        Input image. Tensor of shape [N, H, W, C].

    Outputs
    -------
               Downsampled image. Tensor of shape [N, H/2, W/2, C].
    """

    # Blur by applying a binomial 5x5 kernel with sum mult^2 and subsample by a factor of 2.
    C = img.shape[3]

    # Get kernels, and turn them into a single kernel performing per-channel blurring
    h_kernel, w_kernel = kernels()
    kernel = np.zeros((5, 5, C, C), dtype=np.float32)
    for i in range(C):
        kernel[:, :, i, i] = h_kernel * w_kernel

    return tf.nn.conv2d(img, kernel, strides=(1, 2, 2, 1), padding='SAME')

def upsample(img, output_shape):
    """
    Implement the transpose of to downsample().

    Inputs
    ------
    img           Input image. Tensor of shape [N, H, W, C].
    output_shape  Shape of output image.

    Outputs
    -------
                  Downsampled image. Tensor of shape [N, 2H, 2W, C].
    """
    # Number of channels
    C = img.shape[3]

    # Get kernel for deconvolution (transpose of convolution)
    h_kernel, w_kernel = kernels()
    kernel = np.zeros((5, 5, C, C), dtype=np.float32)
    for i in range(C):
        kernel[:, :, i, i] = h_kernel * w_kernel

    return tf.nn.conv2d_transpose(img, kernel, output_shape, strides=(1, 2, 2, 1), padding='SAME')

def im2pyr(img, num_levels):
    """
    Convert an image into a pyramid.

    Inputs
    ------
    img           Input image. Tensor of shape [N, H, W, C].
    num_levels    Number of pyramid levels.

    Outputs
    -------
    pyr           Image pyramid, represented as a list of tensors of decreasing spatial size.
    """
    # Initialize pyramid using the original image.
    pyr = [img]

    # The next level of the pyramid is a downsampled version of the previous image.
    for n in range(num_levels - 1):
        pyr.append(downsample(pyr[-1]))

    return pyr

def pyr2im(pyr):
    """
    Go from pyramid to image by applying the transpose operator.

    Inputs
    ------
    pyr           Image pyramid, represented as a list of tensors of decreasing spatial size.

    Outputs
    -------
    img           Output image, computed by applying the transpose of the pyramid-generating operator to the pyramid.
    """

    # Initialize by taking the smallest scale.
    img = pyr[-1]

    # For each larger scale, upsample and add the image in the new scale.
    for next_img in pyr[:-1][::-1]:
        img = upsample(img, next_img.shape) + next_img

    return img


import json
from character import *

class jsonReader:
    def __init__(self):
        self._fileName = ''
        self._filePath = ''
        self._content = ''
        self._json = ''

    def setFileNameAndPath(self, fileName, path):
        self._fileName = fileName
        self._filePath = path

    def readFileContent(self):
        with  open(self._filePath + self._fileName, "r") as f:
            _content = f.read()
        print(_content)
        return _content

    def readFileJson(self):
        print(self._filePath + self._fileName)
        with  open(self._filePath + self._fileName, "r") as f:
            self._json = json.load(f)
        return self._json

    def getAllCharacters(self):
        self.readFileJson()
        charactersList=list()
        for elem in self._json:
            ch = Character()
            print(elem['first_name'])
            ch.setCharacter(elem['first_name'],elem['last_name'], elem['pic'], elem['position'], elem['bio'])
            charactersList.append(ch)
        return charactersList


# so 48 - 57
# hoa 65 - 90
# thuong 97 - 122
pas = input()
check = 0
if len(pas) < 5:
    print("Too weak")
else:
    checkLen = True
    checkNum = False
    checkUp = False
    checkLow = False
    for i in pas:
        if ord(i) in range(48, 58):
            checkNum = True
        if ord(i) in range(65, 91):
            checkUp = True
        if ord(i) in range(97, 123):
            checkLow = 1
        if checkNum == True and checkUp == True and checkLow == True:
            break
    if checkNum == True and checkUp == True and checkLow == True:
        print("Correct")
    else:
        print("Too weak")


import setuptools

with open("README.md", "r", encoding="utf-8") as fh:
    long_description = fh.read()

setuptools.setup(
    name="env_validate",
    version="0.04",
    author="Karma Computing",
    author_email="oss@karmacomputing.co.uk",
    desciption="validate env",
    long_description=long_description,
    long_description_content_type="text/markdown",
    include_package_data=True,
    url="https://github.com/chrisjsimpson/env-validate",
    classifiers=(
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: GNU Affero General Public License v3",
        "Operating System :: OS Independent",
    ),
    package_dir={"": "src"},
    packages=setuptools.find_packages(where="src"),
    python_requires=">=3",
)


### DELETE NOTES

from . import all_notes

def delete_note(notes):

    all_notes.all_notes(notes)

    index = int(input("Please enter index (enter 0 to delete all): "))

    if index == 0:
        decision = input("Do you agree to delete all notes? (y/n): ")
        if decision == 'y':
            notes.clear()
            message = 'All notes deleted.'
        else:
            return
    elif index not in range(len(notes)+1):
        message = 'Note does not exist.'
    else:
        decision = input("Do you agree to delete this note? (y/n): ")
        if decision == 'y':
            del notes[index-1]
            message = 'Note successfully deleted.'
        else:
            return

    return message


import pymysql.cursors
import webbrowser
import requests
from google_drive_downloader import GoogleDriveDownloader as gdd
import sys

# Connect to the database.
####################################
connection = pymysql.connect(host='',
                             user='',
                             password='',
                             db='',
                             charset='',
                             cursorclass=pymysql.cursors.DictCursor)

mycursor = connection.cursor()

#### Συναρτήσεις που δίνουν την δυνατότητα στον χρήστη να αναζητήσει ΑΜΕΣΑ δλδ πληκτρολογώντας το ονομα αυτού που ψάχνει
##===================================================================================================================##
def key_words():
    print("Δώσε μας τη λέξη κλειδί για αναζήτηση σε τίτλο άρθρου")
    s1="select `ΤΙΤΛΟΣ`, `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΤΙΤΛΟΣ` LIKE '%s' " %("%"+input()+"%")
    mycursor.execute(s1)
    a=mycursor.fetchall()
    while True:
        if len(a)>1:
            c1=[]
            c2=[]
            for i in a:

                b=i.get('ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ')
                c1.append(b)
                d=i.get('ΤΙΤΛΟΣ')
                c2.append(i.get('ΤΙΤΛΟΣ'))
            what_to_do_with_article(c1,c2)
            break
        elif len(a)==1:
            c1=[]
            c2=[]
            for i in a:
                b=i.get('ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ')
                c1.append(b)
                d=i.get('ΤΙΤΛΟΣ')
                c2.append(i.get('ΤΙΤΛΟΣ'))
            what_to_do_with_article(c1,c2)
            break
        else:
            print("Η αναζήτηση που κάνατε δεν οδήγησε σε κάποιο άρθρο. Προσπαθήστε ξανά...:")
            s1="select `ΤΙΤΛΟΣ`, `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΤΙΤΛΟΣ` LIKE '%s' " %("%"+input()+"%")
            mycursor.execute(s1)
            a=mycursor.fetchall()

def author_search():
    print("Όνοματεπώνυμο συγγραφέα για αναζήτηση:")
    b = input()
    b = b.split()
    b = ''.join(b)
    sql = """   SELECT `ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ` , `ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`
                FROM (select `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` AS `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`,concat(`ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ`,`ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`) AS `flname` from `ΣΥΓΓΡΑΦΕΑΣ`) AS A1
                JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON A1.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                WHERE flname LIKE '%s'""" %("%"+b+"%")
    mycursor.execute(sql)
    a=mycursor.fetchall()

    while True:
        if len(a)>1:
            j=1
            print("\nΗ ΑΝΑΖΗΤΗΣΗ ΣΑΣ ΟΔΗΓΗΣΕ ΣΤΟΥΣ ΑΚΟΛΟΥΘΟΥΣ ΣΥΓΓΡΑΦΕΙΣ:")
            print("=======================================================")
            for i in a:
                print(j,i.get("ΟΝΟΜΑ"), i.get("ΕΠΩΝΥΜΟ"))
                j=j+1
            while True:
                b = (input("ΠΛΗΚΤΡΟΛΟΓΗΣΤΕ ΤΟΝ ΑΡΙΘΜΟ ΠΟΥ ΑΝΤΙΣΤΟΙΧΕΙ ΣΤΟΝ ΣΥΓΓΡΑΦΕΑ ΠΟΥ ΑΝΑΖΗΤΗΣΑΤΕ:"))
                if b.isdigit()==True and int(b)!=0:
                    if int(b)-1 < (j-1):break
                    else:print("\nΔώστε έγκυρο αριθμό...")
                else:print("\nΔώστε έγκυρο αριθμό...")
            string = [a[int(b)-1].get("ΟΝΟΜΑ"),a[int(b)-1].get("ΕΠΩΝΥΜΟ")]
            print(string[0],string[1])
            print("\nΤο προφίλ του συγγραφέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            fa = """SELECT `ΟΝΟΜΑ`, `ΕΠΩΝΥΜΟ`, `ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ`
                    FROM `ΣΥΓΓΡΑΦΕΑΣ`
                    WHERE `ΟΝΟΜΑ` LIKE '%s' AND `ΕΠΩΝΥΜΟ` LIKE '%s'""" %(string[0],string[1])
            mycursor.execute(fa)
            info2 = mycursor.fetchall()
            info22=[]
            for i in info2:
                info22.append(list(i.values()))
            for i in range(len(info22)) :
                print("ΟΝΟΜΑ:",info22[i][0],", ΕΠΩΝΥΜΟ:",info22[i][1], ", ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ:", info22[i][2])
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του συγγραφέα:', string[0], string[1])
            sql="select `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` FROM `ΣΥΓΓΡΑΦΕΑΣ` WHERE `ΟΝΟΜΑ` LIKE '%s' AND `ΕΠΩΝΥΜΟ` LIKE '%s'" %(string[0],string[1])
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        elif len(a)==1:
            print("\nΟ ΣΥΓΓΡΑΦΕΑΣ ΠΟΥ ΒΡΕΘΗΚΕ ΕΙΝΑΙ Ο ΑΚΟΛΟΥΘΟΣ:")
            print("==============================================")
            for i in a:
                s1=i.get("ΟΝΟΜΑ")
                s2=i.get("ΕΠΩΝΥΜΟ")
                print(i.get("ΟΝΟΜΑ"), i.get("ΕΠΩΝΥΜΟ"))

            print("\nΤο προφίλ του συγγραφέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            fa = """SELECT `ΟΝΟΜΑ`, `ΕΠΩΝΥΜΟ`, `ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ`
                    FROM `ΣΥΓΓΡΑΦΕΑΣ`
                    WHERE `ΟΝΟΜΑ` LIKE '%s' AND `ΕΠΩΝΥΜΟ` LIKE '%s'""" %(s1,s2)
            mycursor.execute(fa)
            info2 = mycursor.fetchall()
            info22=[]
            for i in info2:
                info22.append(list(i.values()))
            for i in range(len(info22)) :
                print("ΟΝΟΜΑ:",info22[i][0],", ΕΠΩΝΥΜΟ:",info22[i][1], ", ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ:", info22[i][2])
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του συγγραφέα:', s1, s2)
            sql="select `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` FROM `ΣΥΓΓΡΑΦΕΑΣ` WHERE `ΟΝΟΜΑ` LIKE '%s' AND `ΕΠΩΝΥΜΟ` LIKE '%s'" %(s1,s2)
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        else:
            print("Ο συγγραφέας που αναζητάτε δεν υπάρχει. Προσπαθήστε ξανά...:")
            b = input()
            b = b.split()
            b = ''.join(b)
            sql ="""SELECT `ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ` , `ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`
                    FROM (select `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` AS `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`,concat(`ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ`,`ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`) AS `flname` from `ΣΥΓΓΡΑΦΕΑΣ`) AS A1
                    JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON A1.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                    WHERE flname LIKE '%s' """ %("%"+b+"%")
            mycursor.execute(sql)
            a=mycursor.fetchall()

    if mycursor.rowcount>0:
        a=result[0]['ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ']
        sql="select DISTINCT `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM συγγράφει where `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`='%s'"%a
        mycursor.execute(sql)
        result=mycursor.fetchall()
        result2=[]
        c1=[]
        for i in range(len(result)):
            b=result[i]['ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ']
            c1.append(b)
            sql="select `ΤΙΤΛΟΣ` from `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`='%s'"%b
            mycursor.execute(sql)
            result2.append(mycursor.fetchall())
        if len(result2) !=0:
            c2=[]
            for i in range(len(result2)):
                c2.append(result2[i][0]['ΤΙΤΛΟΣ'])
            what_to_do_with_article(c1,c2)
        else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου συγγραφέα!!\n\n")

    elif mycursor.rowcount==0:
        print("Το όνομα που πληκτρολογήσατε δεν υπάρχει στην λίστα. Προσπαθήστε ξανά..")
        author_search()

def magazine_search():
    print("'Ονομα περιοδικού για αναζήτηση:")
    magaz_name="select `ΟΝΟΜΑ` FROM ΠΕΡΙΟΔΙΚΟ where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
    mycursor.execute(magaz_name)
    a=(mycursor.fetchall())
    while True:
        if len(a)>1:
            j=1
            print("\nΗ ΑΝΑΖΗΤΗΣΗ ΣΑΣ ΟΔΗΓΗΣΕ ΣΤΑ ΑΚΟΛΟΥΘΑ ΠΕΡΙΟΔΙΚΑ:")
            print("==============================================")
            for i in a:
                print(j,i.get("ΟΝΟΜΑ"))
                j=j+1
            while True:
                b = (input("ΠΛΗΚΤΡΟΛΟΓΗΣΤΕ ΤΟΝ ΑΡΙΘΜΟ ΠΟΥ ΑΝΤΙΣΤΟΙΧΕΙ ΣΤΟ ΠΕΡΙΟΔΙΚΟ ΠΟΥ ΑΝΑΖΗΤΗΣΑΤΕ:"))
                if b.isdigit()==True and int(b)!=0:
                    if int(b)-1 < (j-1):break
                    else:print("\nΔώστε έγκυρο αριθμό ...")
                else:print("\nΔώστε έγκυρο αριθμό ...")
            string = a[int(b)-1].get("ΟΝΟΜΑ")
            print("\nΤο προφίλ του περιοδικού που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            fm = """SELECT `ΟΝΟΜΑ`, `ΕΚΔΟΤΗΣ`
            FROM `ΠΕΡΙΟΔΙΚΟ`
            WHERE `ΟΝΟΜΑ` LIKE %s"""
            mycursor.execute(fm,(string,))
            info1 = mycursor.fetchall()
            info11=[]
            for i in info1:
                info11.append(list(i.values()))
            for i in range(len(info11)) :
                print(info11[i][0],", ΕΚΔΟΤΗΣ:",info11[i][1])
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του περιοδικού:', string)
            sql="select `ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` FROM ΠΕΡΙΟΔΙΚΟ where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        elif len(a)==1:
            print("ΤΟ ΠΕΡΙΟΔΙΚΟ ΠΟΥ ΒΡΕΘΗΚΕ ΕΙΝΑΙ ΤΟ ΑΚΟΛΟΥΘΟ:")
            print("==============================================")
            for i in a:
                string=i.get("ΟΝΟΜΑ")
                print(string)
            ## ΠΛΗΡΟΦΟΡΙΕΣ ΓΙΑ ΤΟ ΠΕΡΙΟΔΙΚΟ ΠΟΥ ΒΡΕΘΗΚΕ
            print("\nΤο προφίλ του περιοδικού που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            fm = """SELECT `ΟΝΟΜΑ`, `ΕΚΔΟΤΗΣ`
            FROM `ΠΕΡΙΟΔΙΚΟ`
            WHERE `ΟΝΟΜΑ` LIKE %s"""
            mycursor.execute(fm,(string,))
            info1 = mycursor.fetchall()
            info11=[]
            for i in info1:
                info11.append(list(i.values()))
            for i in range(len(info11)) :
                print(info11[i][0],", ΕΚΔΟΤΗΣ:",info11[i][1])
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του περιοδικού:', string)
            sql="select `ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` FROM ΠΕΡΙΟΔΙΚΟ where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        else:
            print("Το περιοδικό που αναζητάτε δεν υπάρχει. Προσπαθήστε ξανά...:")
            magaz_name="select `ΟΝΟΜΑ` FROM ΠΕΡΙΟΔΙΚΟ where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
            mycursor.execute(magaz_name)
            a=(mycursor.fetchall())

    if mycursor.rowcount>0:
        a=result[0]['ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ']
        sql="select `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM περιλαμβάνεται where `ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`='%s'"%a
        mycursor.execute(sql)
        result=mycursor.fetchall()
        result2=[]
        global c1
        c1=[]
        for i in range(len(result)):
            b=result[i]['ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ']
            c1.append(b)
            sql="select `ΤΙΤΛΟΣ` from `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`='%s'"%b
            mycursor.execute(sql)
            result2.append(mycursor.fetchall())
        if len(result2):
            c2=[]
            for i in range(len(result2)):
                c2.append(result2[i][0]['ΤΙΤΛΟΣ'])
            what_to_do_with_article(c1,c2)
        else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου περιοδικού!!\n\n")

    elif mycursor.rowcount==0:
        print("Το όνομα που πληκτρολογήσατε δεν υπάρχει στην λίστα. Προσπαθήστε ξανά..")
        magazine_search()

def episthmoniko_pedio_search():
    print("Επιστημονικό πεδίο για αναζήτηση:")
    subj_name="select `ΟΝΟΜΑ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
    mycursor.execute(subj_name)
    a=(mycursor.fetchall())
    while True:
        if len(a)>1:
            j=1
            print("Η ΑΝΑΖΗΤΗΣΗ ΣΑΣ ΟΔΗΓΗΣΕ ΣΤΑ ΑΚΟΛΟΥΘΑ ΕΠΙΣΤΗΜΟΝΙΚΑ ΠΕΔΙΑ:")
            print("=======================================================")
            for i in a:
                print(j,i.get("ΟΝΟΜΑ"))
                j=j+1
            while True:
                b = (input("ΠΛΗΚΤΡΟΛΟΓΗΣΤΕ ΤΟΝ ΑΡΙΘΜΟ ΠΟΥ ΑΝΤΙΣΤΟΙΧΕΙ ΣΤΟ ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ ΠΟΥ ΑΝΑΖΗΤΗΣΑΤΕ:"))
                if b.isdigit()==True and int(b)!=0:
                    if int(b)-1 < (j-1):break
                    else:print("\nΔώστε έγκυρο αριθμό...")
                else:print("\nΔώστε έγκυρο αριθμό...")
            string = a[int(b)-1].get("ΟΝΟΜΑ")
            print(string)
            sql="select `ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        elif len(a)==1:
            print("ΤΟ ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ ΠΟΥ ΒΡΕΘΗΚΕ ΕΙΝΑΙ ΤΟ ΑΚΟΛΟΥΘΟ:")
            print("==============================================")
            for i in a:
                string=i.get("ΟΝΟΜΑ")
                print(string)
            sql="select `ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        else:
            print("Το πεδίο που αναζητάτε δεν υπάρχει. Προσπαθήστε ξανά...:")
            subj_name="select `ΟΝΟΜΑ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
            mycursor.execute(subj_name)
            a=(mycursor.fetchall())
    if mycursor.rowcount>0:
        a=result[0]['ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ']
        sql="select `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM αναφέρεται where `ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`='%s'"%a
        mycursor.execute(sql)
        result=mycursor.fetchall()
        result2=[]
        global c1
        c1=[]
        for i in range(len(result)):
            b=result[i]['ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ']
            c1.append(b)
            sql="select `ΤΙΤΛΟΣ` from `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`='%s'"%b
            mycursor.execute(sql)
            result2.append(mycursor.fetchall())
        if len(result2)!=0:
            c2=[]
            for i in range(len(result2)):
                c2.append(result2[i][0]['ΤΙΤΛΟΣ'])
            what_to_do_with_article(c1,c2)
        else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου επιστημονικού πεδίου!!\n\n")

    elif mycursor.rowcount==0:
        print("Το όνομα που πληκτρολογήσατε δεν υπάρχει στην λίστα. Προσπαθήστε ξανά..")
        episthmoniko_pedio_search()

def foreas():
    print("Φορέας για αναζήτηση:")
    foreas_name="select `ΟΝΟΜΑ` FROM `ΦΟΡΕΑΣ` where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
    mycursor.execute(foreas_name)
    a=(mycursor.fetchall())
    while True:
        if len(a)>1:
            j=1
            print("Η ΑΝΑΖΗΤΗΣΗ ΣΑΣ ΟΔΗΓΗΣΕ ΣΤΟΥΣ ΑΚΟΛΟΥΘΟΥΣ ΦΟΡΕΙΣ:")
            print("=======================================================")
            for i in a:
                print(j,i.get("ΟΝΟΜΑ"))
                j=j+1
            while True:
                b = (input("ΠΛΗΚΤΡΟΛΟΓΗΣΤΕ ΤΟΝ ΑΡΙΘΜΟ ΠΟΥ ΑΝΤΙΣΤΟΙΧΕΙ ΣΤΟΝ ΦΟΡΕΑ ΠΟΥ ΑΝΑΖΗΤΗΣΑΤΕ:"))
                if b.isdigit()==True and int(b)!=0:
                    if int(b)-1 < (j-1):break
                    else:print("\nΔώστε έγκυρο αριθμό...")
                else:print("\nΔώστε έγκυρο αριθμό...")
            string = a[int(b)-1].get("ΟΝΟΜΑ")
            print(string)
            print("\nΤο προφίλ του φορέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")

            fi = """SELECT `ΟΝΟΜΑ`, `ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ`, `ΧΩΡΑ`
            FROM `ΦΟΡΕΑΣ`
            WHERE `ΟΝΟΜΑ` = %s"""
            mycursor.execute(fi,(string,))
            info3 = mycursor.fetchall()
            info33=[]
            for i in info3:
                info33.append(list(i.values()))
            for i in range(len(info33)) :
                print("ΟΝΟΜΑ:",info33[i][0],", ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ:",info33[i][1], ", ΧΩΡΑ ΦΟΡΕΑ:", info33[i][2])

            print("=======================================================")
            sql="select `ΚΩΔΙΚΟΣ ΦΟΡΕΑ` FROM `ΦΟΡΕΑΣ` where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        elif len(a)==1:
            print("Ο ΦΟΡΕΑΣ ΠΟΥ ΒΡΕΘΗΚΕ ΕΙΝΑΙ Ο ΑΚΟΛΟΥΘΟΣ:")
            print("==============================================")
            for i in a:
                string=i.get("ΟΝΟΜΑ")
                print(string)

            print("\nΤο προφίλ του φορέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            fi = """SELECT `ΟΝΟΜΑ`, `ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ`, `ΧΩΡΑ`
            FROM `ΦΟΡΕΑΣ`
            WHERE `ΟΝΟΜΑ` = %s"""
            mycursor.execute(fi,(string,))
            info3 = mycursor.fetchall()
            info33=[]
            for i in info3:
                info33.append(list(i.values()))
            for i in range(len(info33)) :
                print("ΟΝΟΜΑ:",info33[i][0],", ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ:",info33[i][1], ", ΧΩΡΑ ΦΟΡΕΑ:", info33[i][2])

            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του φορέα:', string)

            sql="select `ΚΩΔΙΚΟΣ ΦΟΡΕΑ` FROM `ΦΟΡΕΑΣ` where `ΟΝΟΜΑ` LIKE '%s' " %string
            mycursor.execute(sql)
            result=mycursor.fetchall()
            break
        else:
            print("Ο φορέας που αναζητάτε δεν υπάρχει. Προσπαθήστε ξανά...:")
            foreas_name="select `ΟΝΟΜΑ` FROM `ΦΟΡΕΑΣ` where `ΟΝΟΜΑ` LIKE '%s' " %("%"+input()+"%")
            mycursor.execute(foreas_name)
            a=(mycursor.fetchall())

    if mycursor.rowcount>0:
        a=result[0]['ΚΩΔΙΚΟΣ ΦΟΡΕΑ']
        sql="select DISTINCT `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM συγγράφει where `ΚΩΔΙΚΟΣ ΦΟΡΕΑ`='%s'"%a
        mycursor.execute(sql)
        result=mycursor.fetchall()
        result2=[]
        global c1
        c1=[]
        for i in range(len(result)):
            b=result[i]['ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ']
            c1.append(b)
            sql="select `ΤΙΤΛΟΣ` from `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` where `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`='%s'"%b
            mycursor.execute(sql)
            result2.append(mycursor.fetchall())
        if len(result2)!=0:
            c2=[]
            for i in range(len(result2)):
                c2.append(result2[i][0]['ΤΙΤΛΟΣ'])
            what_to_do_with_article(c1,c2)
        else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου επιστημονικού φορέα!!\n\n")

    elif mycursor.rowcount==0:
        print("Το όνομα που πληκτρολογήσατε δεν υπάρχει στην λίστα. Προσπαθήστε ξανά..")
        foreas()

##==============================================================================##

#### Συναρτήσεις που δημιουργούν τις αντίστοιχες λίστες από όπου ξεκινάμε για την εύρεση ενός άρθρου
##==============================================================================##
##Συνάρτηση που δημιουργεί μία λίστα με τα ονόματα όλων των επιστημονικών πεδίών
def create_subject():
    subjects= "SELECT `ΟΝΟΜΑ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`"
    mycursor.execute(subjects)
    result = mycursor.fetchall()
    subject = []
    for a in result:
        subject=subject+(list(a.values()))
    return subject
##Συνάρτηση που δημιουργεί μία λίστα με τα ονόματα από όλους τους συγγραφείς
def create_author():
    authors="SELECT `ΟΝΟΜΑ`, `ΕΠΩΝΥΜΟ` FROM `ΣΥΓΓΡΑΦΕΑΣ`"
    mycursor.execute(authors)
    result1 = mycursor.fetchall()
    author=[]
    for i in result1:
        author.append(list(i.values()))
    return author
##Συνάρτηση που δημιουργεί μία λίστα με τα ονόματα όλων των φορέων
def create_institutions():
    institutions = "SELECT `ΟΝΟΜΑ` FROM `ΦΟΡΕΑΣ`"
    mycursor.execute(institutions)
    result2 = mycursor.fetchall()
    institution = []
    for i in result2:
        institution.append(list(i.values()))
    return institution
##Συνάρτηση που δημιουργεί μία λίστα με τα ονόματα όλων των περιοδικών
def create_magazines():
    magazines = "SELECT `ΟΝΟΜΑ` FROM `ΠΕΡΙΟΔΙΚΟ`"
    mycursor.execute(magazines)
    result3 = mycursor.fetchall()
    magazine = []
    for i in result3:
        magazine.append(list(i.values()))
    return magazine

##==============================================================================##
## Βρίσκει πληροφορίες για ένα περιοδικό
def full_magaz(specific_magazine):
    maglen=len(specific_magazine)
    if maglen==1 and specific_magazine!="9":
        p = "10000"
    elif maglen==2 or specific_magazine =="9": p = "1000"
    kod_per = p + str(int(specific_magazine)+1)
    fm = """SELECT `ΟΝΟΜΑ`, `ΕΚΔΟΤΗΣ`
            FROM `ΠΕΡΙΟΔΙΚΟ`
            WHERE `ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = %s"""
    mycursor.execute(fm,(kod_per,))
    info1 = mycursor.fetchall()
    info11=[]
    for i in info1:
        info11.append(list(i.values()))
    for i in range(len(info11)) :
        print(info11[i][0],", ΕΚΔΟΤΗΣ:",info11[i][1])

## Βρίσκει πληροφορίες για ένα συγγραφέα
def full_auth(specific_author):
    autlen=len(specific_author)

    if autlen==1 and specific_author!="9":
        st = "20000"
    elif autlen == 2 or specific_author=="9": st = "2000"
    kod_sygg = st + str(int(specific_author)+1)
    fa = """SELECT `ΟΝΟΜΑ`, `ΕΠΩΝΥΜΟ`, `ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ`
            FROM `ΣΥΓΓΡΑΦΕΑΣ`
            WHERE `ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = %s"""
    mycursor.execute(fa,(kod_sygg,))
    info2 = mycursor.fetchall()
    info22=[]
    for i in info2:
        info22.append(list(i.values()))
    for i in range(len(info22)) :
        print("ΟΝΟΜΑ:",info22[i][0],", ΕΠΩΝΥΜΟ:",info22[i][1], ", ΧΩΡΑ ΚΑΤΑΓΩΓΗΣ:", info22[i][2])
## Βρίσκει πληροφορίες για ένα πεδίο

def full_inst(specific_inst):
    instlen=len(specific_inst)
    if instlen==1 and specific_inst!="9":
        f = "30000"
    elif instlen==2 or specific_inst=="9": f = "3000"
    kod_forea = f + str(int(specific_inst)+1)
    fi = """SELECT `ΟΝΟΜΑ`, `ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ`, `ΧΩΡΑ`
            FROM `ΦΟΡΕΑΣ`
            WHERE `ΚΩΔΙΚΟΣ ΦΟΡΕΑ` = %s"""
    mycursor.execute(fi,(kod_forea,))
    info3 = mycursor.fetchall()
    info33=[]
    for i in info3:
        info33.append(list(i.values()))
    for i in range(len(info33)) :
        print("ΟΝΟΜΑ:",info33[i][0],", ΚΑΤΗΓΟΡΙΑ ΦΟΡΕΑ:",info33[i][1], ", ΧΩΡΑ ΦΟΡΕΑ:", info33[i][2])

## Βρίσκει αναλυτικές πληροφορίες για ένα άρθρο
def information(kod_arthrou):

    titlos = """ SELECT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`
                 FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
                 WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    glwssa = """SELECT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΓΛΩΣΣΑ`
                 FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
                 WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    syggrafeas= """ SELECT DISTINCT `ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ`, `ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`
                    FROM `συγγράφει`
                    JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                    WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    foreas = """SELECT DISTINCT `ΦΟΡΕΑΣ`.`ΟΝΟΜΑ`
                FROM `συγγράφει`
                JOIN `ΦΟΡΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ` = `ΦΟΡΕΑΣ`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`
                WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    im_ekdosis= """SELECT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΗΜΕΡΟΜΗΝΙΑ ΕΚΔΟΣΗΣ`
                   FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
                   WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    periodiko="""SELECT `ΠΕΡΙΟΔΙΚΟ`.`ΟΝΟΜΑ` , `ΤΕΥΧΟΣ`.`VOLUME`, `ΤΕΥΧΟΣ`.`ISSUE`, `περιλαμβάνεται`.`ΣΕΛΙΔΕΣ`
                 FROM  `ΤΕΥΧΟΣ`
                 JOIN `περιλαμβάνεται` ON `ΤΕΥΧΟΣ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` AND `ΤΕΥΧΟΣ`.`VOLUME` = `περιλαμβάνεται`.`VOLUME` AND `ΤΕΥΧΟΣ`.`ISSUE` = `περιλαμβάνεται`.`ISSUE`
                 JOIN `ΠΕΡΙΟΔΙΚΟ` ON `ΤΕΥΧΟΣ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = `ΠΕΡΙΟΔΙΚΟ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`
                 WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s"""

    pedio= """SELECT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΟΝΟΜΑ`
              FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`
              JOIN `αναφέρεται` ON `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` = `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
              WHERE `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`= %s"""
    mycursor.execute(titlos,(kod_arthrou,))
    t = mycursor.fetchall()
    mycursor.execute(glwssa,(kod_arthrou,))
    g = mycursor.fetchall()
    mycursor.execute(syggrafeas,(kod_arthrou,))
    s = mycursor.fetchall()
    mycursor.execute(foreas,(kod_arthrou,))
    f = mycursor.fetchall()
    mycursor.execute(im_ekdosis,(kod_arthrou,))
    im = mycursor.fetchall()
    mycursor.execute(periodiko,(kod_arthrou,))
    per = mycursor.fetchall()
    mycursor.execute(pedio,(kod_arthrou,))
    ped = mycursor.fetchall()

    print("\nΑναζήτηση πληροφοριών του άρθρου ...")
    T=[]
    print("\nΤΙΤΛΟΣ")
    print("===========")
    for i in t:
        T.append(list(i.values()))
    for i in range(len(T)) :
        print(T[i][0])
    print("\n")

    print("ΓΛΩΣΣΑ")
    print("=======")
    print(g[0].get("ΓΛΩΣΣΑ"))
    print("\n")

    S=[]
    print("ΣΥΓΓΡΑΦΕΙΣ")
    print("===========")
    for i in s:
        S.append(list(i.values()))
    for i in range(len(S)) :
        print(S[i][0],S[i][1])
    print("\n")

    F=[]
    print("ΦΟΡΕΑΣ")
    print("===========")
    for i in f:
        F.append(list(i.values()))
    for i in range(len(F)) :
        print(F[i][0])
    print("\n")

    IM=[]
    print("ΗΜΕΡΟΜΗΝΙΑ ΕΚΔΟΣΗΣ")
    print("==================")
    for i in im:
        IM.append(list(i.values()))
    for i in range(len(IM)) :
        print(IM[i][0])
    print("\n")

    PER=[]
    print("ΠΕΡΙΟΔΙΚΟ")
    print("==================")
    for i in per:
        PER.append(list(i.values()))
    for i in range(len(PER)) :
        print(PER[i][0],", volume:",PER[i][1],", issue:",PER[i][2],", σελίδες:",PER[i][3])
    print("\n")

    PED=[]
    print("ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ")
    print("==================")
    for i in ped:
        PED.append(list(i.values()))
    for i in range(len(PED)) :
        print(PED[i][0])
    print("\n")
    print("\nΕπιστροφή στο μενού άρθρου...")

## ΠΑΡΑΠΟΜΠΕΣ

def parapompes(kod_arthrou):

    par_ektos = """ SELECT concat_ws(', ',`ΕΠΩΝΥΜΟ ΣΥΓΓΡΑΦΕΑ`, CONCAT("(",`ΕΤΟΣ ΚΥΚΛΟΦΟΡΙΑΣ`,")"), `ΤΙΤΛΟΣ ΑΡΘΡΟΥ`, `ΟΝΟΜΑ ΤΕΚΜΗΡΙΟΥ`,CONCAT("pp.",`ΣΕΛΙΔΕΣ`), `ΕΚΔΟΤΗΣ`)  as par_ektos
                    FROM `ΠΑΡΑΠΟΜΠΗ`
                    JOIN (select `ΣΥΓΓΡΑΦΕAΣ ΠΑΡΑΠΟΜΠΗΣ`.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ` AS `ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ`,group_concat(`ΣΥΓΓΡΑΦΕAΣ ΠΑΡΑΠΟΜΠΗΣ`.`ΕΠΩΝΥΜΟ ΣΥΓΓΡΑΦΕΑ` separator ', ') AS `ΕΠΩΝΥΜΟ ΣΥΓΓΡΑΦΕΑ` from `ΣΥΓΓΡΑΦΕAΣ ΠΑΡΑΠΟΜΠΗΣ`
                    group by `ΣΥΓΓΡΑΦΕAΣ ΠΑΡΑΠΟΜΠΗΣ`.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ`) AS syggr ON `ΠΑΡΑΠΟΜΠΗ`.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ`=syggr.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ`
                    JOIN `παραπέμπει εκτός` ON `ΠΑΡΑΠΟΜΠΗ`.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΟΜΠΗΣ` = `παραπέμπει εκτός`.`ΚΩΔΙΚΟΣ ΠΑΡΑΠΜΠΗΣ`
                    WHERE `παραπέμπει εκτός`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s""" %kod_arthrou
    mycursor.execute(par_ektos)
    ektos=mycursor.fetchall()
    par_entos =  """SELECT kod_deuterou, titlos, concat_ws(', ',eponimo, xronos, titlos, onoma, CONCAT("pp.",selides), CONCAT('vol: ', vol), CONCAT('iss :' , iss),`ΕΚΔΟΤΗΣ` ) as par_entos
                    FROM (SELECT GROUP_CONCAT(DISTINCT CONCAT(`ΕΠΩΝΥΜΟ`,' ',SUBSTRING(`ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ`,1,1),". ")) as eponimo, CONCAT("(",YEAR(`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΗΜΕΡΟΜΗΝΙΑ ΕΚΔΟΣΗΣ`),")") as xronos,
                          `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ` as titlos, `ΠΕΡΙΟΔΙΚΟ`.`ΟΝΟΜΑ` as onoma, `ΤΕΥΧΟΣ`.`VOLUME` as vol, `ΤΕΥΧΟΣ`.`ISSUE` as iss, `περιλαμβάνεται`.`ΣΕΛΙΔΕΣ` as selides, `ΠΕΡΙΟΔΙΚΟ`.`ΕΚΔΟΤΗΣ`,
                          `παραπέμπει εντός`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ ΔΕΥΤΕΡΟΥ` as kod_deuterou
                    FROM `συγγράφει`
                    JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                    JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                    JOIN `παραπέμπει εντός` on`συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = `παραπέμπει εντός`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ ΔΕΥΤΕΡΟΥ`
                    JOIN `περιλαμβάνεται` ON `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                    JOIN `ΤΕΥΧΟΣ` ON `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = `ΤΕΥΧΟΣ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` AND `περιλαμβάνεται`.`VOLUME` = `ΤΕΥΧΟΣ`.`VOLUME` AND `περιλαμβάνεται`.`ISSUE` = `ΤΕΥΧΟΣ`.`ISSUE`
                    JOIN `ΠΕΡΙΟΔΙΚΟ` ON `ΤΕΥΧΟΣ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = `ΠΕΡΙΟΔΙΚΟ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`
                    WHERE `παραπέμπει εντός`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ ΠΡΩΤΟΥ` = %s
                    GROUP BY `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`) as what""" %kod_arthrou
    mycursor.execute(par_entos)
    entos=mycursor.fetchall()

    print("\nΑναζήτηση παραπομπών του άρθρου ...")
    j=1
    if len(ektos)!=0 or len(entos) !=0 :
        print("\nΠΑΡΑΠΟΜΠΕΣ")
        print("==========================")
        if len(ektos) != 0:
            for i in ektos:
                print(j,i.get("par_ektos"))
                j=j+1
                print("\n")
        if len(entos) !=0:
            c1=[]
            c2=[]
            c3=[]
            for i in entos:
                c1.append(i.get("kod_deuterou"))
                c2.append(i.get("titlos"))
                c3.append(i.get("par_entos"))
                print(j,i.get("par_entos"))
                j=j+1
                print("\n")
            print("==========================\n")
            if len(c2) == 1:
                print("\nΗ παρακάτω παραπομπή υπάρχει στην βάση δεδομένων μας\n")
                print("=========================================================")
                print(c3[0])
                print("=========================================================")
                print("\nΑν θέλετε να την επιλέξετε πατήστε 1.")
                print("Αν δεν θέλετε να την επιλέξετε πατήστε 2.")
            else:
                print("\nΟι παρακάτω παραπομπές υπάρχουν στην βάση δεδομένων μας\n")
                print("=========================================================")
                for i in c3:print(i)
                print("=========================================================\n")
                print("Αν θέλετε να επιλέξετε κάποια απο αυτές πατήστε 1.")
                print("Αν δεν θέλετε να επιλέξετε κάποια πατήστε 2.")
            ans=str(input())
            if ans=="1":what_to_do_with_article(c1,c2)

    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν παραπομπές του συγκεκριμένου άρθρου!!\n\n")
    print("\nΕπιστροφή στο μενού άρθρου...")

##Συνάρτηση που δίνει την δυνατότηα στον χρήστη να αποφασίσει τι θέλει να κάνει με το άρθρο που βρήκε
def what_to_do_with_article(lista_kod_arthr, lista_titlwn):
    while True:
        print("\n\nΕΠΙΣΤΗΜΟΝΙΚΑ ΑΡΘΡΑ")
        print("====================\n")
        j=1
        for i in lista_titlwn:
            print(j,i)
            j=j+1
            print("\n")
        print("=========================\n")
        m=0
        while len(lista_kod_arthr)!=1:
            print("--Πληκτρολογείστε τον αριθμό του άρθρου που θέλετε να επιλέξετε:")
            print("--(Enter) για να πάτε πίσω")
            b = input()
            if b.isdigit()==True:
                if int(b)-1 < len(lista_kod_arthr) and int(b)!=0:break
                else:print("\nΔώστε έγκυρο αριθμό άρθρου...")
            elif b=="":break
            else:print("\nΔώστε έγκυρο αριθμό άρθρου...")
        if len(lista_kod_arthr)!=1 and b=="": break
        if len(lista_kod_arthr)==1:
            b="1"
            m=1

        add_to_history(lista_kod_arthr[int(b)-1])
        while True:
            if len(lista_kod_arthr)!=1:
                print("\nΤο άρθρο που επιλέξατε ειναι το:\n")
                print("====================================")
                print(lista_titlwn[int(b)-1])
                print("====================================")
            print("\nΜΕΝΟΥ ΑΡΘΡΟΥ")
            print("===============")
            print("1: Πρόσθεση-Αφαίρεση άρθρου από τα αγαπημένα.")
            print("2: Άνοιγμα άρθρου σε μορφή .pdf.")
            print("3: Αναλυτικές πληροφορίες άρθρου.")
            print("4: Παραπομπές άρθρου.")
            print("5: Αναζήτηση μέσω του συγκεκριμένου άρθρου.")
            print("6: Κατέβασμα του συγκεκριμένου άρθρου.")
            print("(ENTER): Για να πάτε πίσω.")

            c = input()
            if c=="1":add_to_favourites(lista_kod_arthr[int(b)-1])
            elif c=="2":open_art(lista_kod_arthr[int(b)-1])
            elif c=="3":information(lista_kod_arthr[int(b)-1])
            elif c=="4":parapompes(lista_kod_arthr[int(b)-1])
            elif c=="5":

                print("\nΕΠΙΛΟΓΕΣ ΑΝΑΖΗΤΗΣΗΣ")
                print("=====================")
                print("1: Αναζήτηση άρθρων που αναφέρονται στο πεδίο του επιλεγμένου άρθρου.")
                print("2: Αναζήτηση άρθρων που έχουν συγγραφεί από τον συγγραφέα του επιλεγμένου άρθρου.")
                print("3: Αναζήτηση άρθρων που έχουν εκδοθεί από τους φορεις του επιλεγμένου άρθρου.")
                print("4: Αναζήτηση άρθρων που έχουν εκδοθεί από το περιοδικό του επιλεγμένου άρθρου.")
                print("5: Για να πάτε πίσω.")
                so = input()
                if so == "1":ep_pedio(lista_kod_arthr[int(b)-1])
                elif so == "2":syggr(lista_kod_arthr[int(b)-1])
                elif so == "3":ep_foreas(lista_kod_arthr[int(b)-1])
                elif so == "4":ep_per(lista_kod_arthr[int(b)-1])
                elif so == "5":c =""
                else:print("\nΠροσπαθήστε ξανά...\n")
            elif c=="":
                break
            elif c=="6":
                download_article(lista_kod_arthr[int(b)-1])
            else:print("\nΠροσπαθήστε ξανά...\n")
        if c=="" and m==1:break

def download_article(kod_arthrou):
    sql = """SELECT DOWNLOAD_URL
            FROM`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
            WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s""" %kod_arthrou
    mycursor.execute(sql)
    a = mycursor.fetchall()
    url = a[0].get('DOWNLOAD_URL')
    print("\n\nΠεριμένετε να κατέβει το άρθρο...\n\n\n")
    gdd.download_file_from_google_drive(url,'./downloads/%s.pdf'%kod_arthrou)
    print("Το άρθρο κατέβηκε επιτυχώς!!")
    print("=============================")

## Συνάρτηση που ανοίγει pdf files από το google drive
def open_art(kod_arthrou):
    sql = """SELECT OPEN_URL
            FROM`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
            WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s""" %kod_arthrou
    mycursor.execute(sql)
    a = mycursor.fetchall()
    url = a[0].get('OPEN_URL')

    print(url)

    print("\nΆνοιγμα του άρθρου ...")
    print("\nΕπιστροφή στο μενού άρθρου...")
    webbrowser.open_new(url)

####Συναρτήσεις που τυπώνουν άρθρα ίδιου φίλτρου
##Ιδιου επιστημονικου πεδιου
##====================================================
def ep_pedio(kod_arthrou):
    sql ="""SELECT DISTINCT `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`,`ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΟΝΟΜΑ`
            FROM `αναφέρεται`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` ON `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
            WHERE `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` IN (SELECT `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
                                                                FROM `αναφέρεται`
                                                                WHERE `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)
            AND `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`!=%s""" %(kod_arthrou,kod_arthrou)
    c1=[]
    c2=[]
    mycursor.execute(sql)
    result=mycursor.fetchall()
    sql1 ="""SELECT DISTINCT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΟΝΟΜΑ`
            FROM `αναφέρεται`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` ON `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
            WHERE `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` IN (SELECT `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
                                                                FROM `αναφέρεται`
                                                                WHERE `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)""" %(kod_arthrou)
    mycursor.execute(sql1)
    a=mycursor.fetchall()
    if len(a)>1:
        print("\n\n============================================================")
        print("Το άρθρο αναφέρεται στα ακόλουθα επιστημονικά πεδία:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"))
        print("\n\nΟκ, αναζήτηση άλλων σχετικών με τα συγκεκριμένα πεδία άρθρων...\n")
        print("============================================================")
    elif len(a)==1:
        print("\n\n============================================================")
        print("Το άρθρο αναφέρεται στο ακόλουθο επιστημονικό πεδίο:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"))
        print("\n\nΟκ, αναζήτηση άλλων σχετικών με το συγκεκριμένο πεδίο άρθρων...\n")
        print("============================================================")
    if len(result)!=0:
        for i in result:
            c1.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
            c2.append(i.get("ΤΙΤΛΟΣ"))

        what_to_do_with_article(c1,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άλλα άρθρα του συγκεκριμένου πεδίου!!\n\n")

def syggr(kod_arthrou):
    sql ="""SELECT DISTINCT `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`
            FROM `συγγράφει`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
            WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` IN (SELECT  `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                                                                FROM `συγγράφει`
                                                                WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)
            AND `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`!=%s""" %(kod_arthrou,kod_arthrou)
    c1=[]
    c2=[]
    mycursor.execute(sql)
    result=mycursor.fetchall()
    sql1 ="""SELECT DISTINCT `ΣΥΓΓΡΑΦΕΑΣ`.`ΟΝΟΜΑ`,`ΣΥΓΓΡΑΦΕΑΣ`.`ΕΠΩΝΥΜΟ`
            FROM `συγγράφει`
            JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
            WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` IN (SELECT  `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
                                                                FROM `συγγράφει`
                                                                WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)""" %(kod_arthrou)

    mycursor.execute(sql1)
    a=mycursor.fetchall()
    if len(a)>1:
        print("\n\n============================================================")
        print("Το άρθρο έχει συγγραφεί από τους ακόλουθους συγγραφείς:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"),i.get("ΕΠΩΝΥΜΟ"))
        print("\n\nΟκ, αναζήτηση άρθρων των συγκεκριμένων συγγραφέων...\n")
        print("============================================================")
    elif len(a)==1:
        print("\n\n============================================================")
        print("Το άρθρο έχει συγγραφεί από τον ακόλουθο συγγραφέα:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"),i.get("ΕΠΩΝΥΜΟ"))
        print("\n\nΟκ, αναζήτηση άρθρων του συγκεκριμένου συγγραφέα...\n")
        print("============================================================")
    if len(result)!=0:
        for i in result:
            c1.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
            c2.append(i.get("ΤΙΤΛΟΣ"))
        what_to_do_with_article(c1,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άλλα άρθρα του συγκεκριμένου συγγραφέα!!\n\n")

def ep_foreas(kod_arthrou):
    sql ="""SELECT DISTINCT `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`
            FROM `συγγράφει`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ` IN (SELECT  `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`
                                                                FROM `συγγράφει`
                                                                WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)
            AND `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`!=%s""" %(kod_arthrou,kod_arthrou)
    c1=[]
    c2=[]
    mycursor.execute(sql)
    result=mycursor.fetchall()
    sql1 ="""SELECT DISTINCT `ΦΟΡΕΑΣ`.`ΟΝΟΜΑ`
            FROM `συγγράφει`
            JOIN `ΦΟΡΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`=`ΦΟΡΕΑΣ`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`
            WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ` IN (SELECT  `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`
                                                                FROM `συγγράφει`
                                                                WHERE `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)""" %(kod_arthrou)
    mycursor.execute(sql1)
    a=mycursor.fetchall()
    if len(a)>1:
        print("\n\n============================================================")
        print("Το άρθρο εκδόθηκε σε συνεργασια με τους ακόλουθους φορείς:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"))
        print("\n\nΟκ, αναζήτηση άρθρων των συγκεκριμένων φορέων...\n")
        print("============================================================")
    elif len(a)==1:
        print("\n\n============================================================")
        print("Το άρθρο εκδόθηκε σε συνεργασια με τον ακόλουθο φορέα:")
        for i in a:
            print(i.get("ΟΝΟΜΑ"))
        print("\n\nΟκ, αναζήτηση άρθρων του συγκεκριμένου φορέα...\n")
        print("============================================================")
    if len(result)!=0:
        for i in result:
            c1.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
            c2.append(i.get("ΤΙΤΛΟΣ"))
        what_to_do_with_article(c1,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άλλα άρθρα του συγκεκριμένου φορέα!!\n\n")

def ep_per(kod_arthrou):
    sql ="""SELECT DISTINCT `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`
            FROM `περιλαμβάνεται`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=`ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` IN (SELECT  `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`
                                                                FROM `περιλαμβάνεται`
                                                                WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)
            AND `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`!=%s""" %(kod_arthrou,kod_arthrou)
    c1=[]
    c2=[]
    mycursor.execute(sql)
    result=mycursor.fetchall()
    sql1 ="""SELECT DISTINCT `ΠΕΡΙΟΔΙΚΟ`.`ΟΝΟΜΑ`
            FROM `περιλαμβάνεται`
            JOIN `ΠΕΡΙΟΔΙΚΟ` ON `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` = `ΠΕΡΙΟΔΙΚΟ`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`
            WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ` IN (SELECT  `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`
                                                                FROM `περιλαμβάνεται`
                                                                WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`=%s)""" %(kod_arthrou)
    mycursor.execute(sql1)
    a=mycursor.fetchall()

    print("\n\n============================================================")
    print("Το άρθρο εκδόθηκε από το ακόλουθο περιοδικό:")
    for i in a:
        print(i.get("ΟΝΟΜΑ"))
    print("\n\nΟκ, αναζήτηση άλλων άρθρων του συγκεκριμένου περιοδικού...\n")
    print("============================================================")
    if len(result)!=0:
        for i in result:
            c1.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
            c2.append(i.get("ΤΙΤΛΟΣ"))
        what_to_do_with_article(c1,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άλλα άρθρα του συγκεκριμένου περιοδικού!!\n\n")

##====================================================

def add_to_history(kod_arthrou):

    try:
        file = open("history.txt","r+")
    except IOError:
        file = open("history.txt","w+")

    data = file.read().splitlines()
    file.close()
    a=len(data)
    if a == 0:
        hist = open("history.txt","a")
        hist.write(kod_arthrou)
        hist.write("\n")
        hist.close()
    elif a!=0 and kod_arthrou!=data[-1]:
        hist = open("history.txt","a")
        hist.write(kod_arthrou)
        hist.write("\n")
        hist.close()

def open_history():
    hist = open("history.txt","r+")
    data = hist.read().splitlines()
    hist.close()
    c1=[]
    c2=[]
    if len(data)!=0:
        for i in data:
            if i != "":
                c1.append(i)
        for i in c1:
            sql ="""SELECT `ΤΙΤΛΟΣ`
                    FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
                    WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s """%i
            mycursor.execute(sql)
            result=mycursor.fetchall()
            c2.append(result[0].get("ΤΙΤΛΟΣ"))
        what_to_do_with_article(c1,c2)
    else:print("\nΤΟ ΙΣΤΟΡΙΚΟ ΑΝΑΖΗΤΗΣΕΩΝ ΣΑΣ ΕΙΝΑΙ ΚΕΝΟ !!")

def add_to_favourites(kod_arthrou):
    try:
        fav = open("favourites.txt","r+")
    except IOError:
        fav = open("favourites.txt","w+")

    data = fav.read().splitlines()
    fav.close()

    if (kod_arthrou in data):
        print("\n\nΤΟ ΣΥΓΚΕΚΡΙΜΕΝΟ ΑΡΘΡΟ ΕΙΝΑΙ ΗΔΗ ΣΤΑ ΑΓΑΠΗΜΕΝΑ !!")
        print("====================================================")
        print("\n\nΑν θέλετε να το αφιρέσετε απο τα αγαπημένα πατήστε 1")
        print("Αν όχι πατήστε κάτι για να συνεχίσετε.\n")
        a = input()
        if a=="1":
            fav = open("favourites.txt","r+")
            data = fav.read()
            data = data.replace(kod_arthrou,"")
            fav.close()
            fav = open("favourites.txt","w")
            fav.write(data)
            fav.close()
            print("\n\nΤΟ ΣΥΓΚΕΚΡΙΜΕΝΟ ΑΡΘΡΟ ΑΦΑΙΡΕΘΗΚΕ ΕΠΙΤΥΧΩΣ ΑΠΟ ΤΑ ΑΓΑΠΗΜΕΝΑ !!")
    else:
        fav = open("favourites.txt","a")
        fav.write(kod_arthrou)
        fav.write("\n")
        fav.close()
        print("\n\nΤΟ ΣΥΓΚΕΚΡΙΜΕΝΟ ΑΡΘΡΟ ΠΡΟΣΤΕΘΗΚΕ ΕΠΙΤΥΧΩΣ ΣΤΑ ΑΓΑΠΗΜΕΝΑ!!")
        print("====================================================")

def open_favourites():
    fav = open("favourites.txt","r+")
    data = fav.read().splitlines()
    fav.close()
    c1=[]
    c2=[]
    if len(data)!=0:
        for i in data:
            if i != "":
                c1.append(i)
        for i in c1:
            sql ="""SELECT `ΤΙΤΛΟΣ`
                    FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`
                    WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = %s """%i
            mycursor.execute(sql)
            result=mycursor.fetchall()
            c2.append(result[0].get("ΤΙΤΛΟΣ"))
        what_to_do_with_article(c1,c2)
    else:print("\nΔΕΝ ΕΧΕΙ ΠΡΟΣΤΕΘΕΙ ΑΚΟΜΑ ΚΑΤΙ ΣΤΑ ΑΓΑΠΗΜΕΝΑ\n\n")

#### Συναρτήσεις που μέσω query βρίσκουν τα ζητούμενα επιστημονικά άρθρα
##==============================================================================##

##Συνάρτηση που επιστρέφει επιστημονικά άρθρα που αντιστοιχούν σε ένα επιστημονικό πεδίο
def sub_to_art(specific_subject):
    arts = """SELECT `ΤΙΤΛΟΣ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            FROM `αναφέρεται`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON  `αναφέρεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` =  `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ` ON `αναφέρεται`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ` =  `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΚΩΔΙΚΟΣ ΕΠΙΣΤΗΜΟΝΙΚΟΥ ΠΕΔΙΟΥ`
            WHERE `ΕΠΙΣΤΗΜΟΝΙΚΟ ΠΕΔΙΟ`.`ΟΝΟΜΑ` LIKE %s"""
    mycursor.execute(arts,(specific_subject ,))
    result1 = mycursor.fetchall()
    global kod_arthr
    kod_arthr=[]
    al=[]
    c2=[]
    if len(result1)!=0:
        for i in result1:
            al.append(list(i.values()))
            kod_arthr.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
        for i in range(len(al)) :
            c2.append(al[i][0])

        what_to_do_with_article(kod_arthr,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου πεδίου!!\n\n")

##Συνάρτηση που επιστρέφει επιστημονικά άρθρα που αντιστοιχούν σε ένα συγγραφέα
def aut_to_art(specific_author):
    autlen=len(specific_author)
    ar = """SELECT DISTINCT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            FROM `συγγράφει`
            JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
            JOIN `ΣΥΓΓΡΑΦΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ`
            WHERE `ΣΥΓΓΡΑΦΕΑΣ`.`ΚΩΔΙΚΟΣ ΣΥΓΓΡΑΦΕΑ` = %s"""
    if autlen==1 and specific_author!="9":
        st = "20000"
    elif autlen == 2 or specific_author=="9": st = "2000"
    kod_sygg = st + str(int(specific_author)+1)
    mycursor.execute(ar,(kod_sygg))
    result2 = mycursor.fetchall()
    global kod_arthr
    kod_arthr=[]
    al=[]
    c2=[]
    if len(result2)!=0:
        for i in result2:
            al.append(list(i.values()))
            kod_arthr.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
        for i in range(len(al)) :
            c2.append(al[i][0])
        what_to_do_with_article(kod_arthr,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου συγγραφέα!!\n\n")

##Συνάρτηση που επιστρέφει επιστημονικά άρθρα που αντιστοιχούν σε έναν φορέα
def ins_to_art(specific_inst):
    instlen=len(specific_inst)
    ar1 = """ SELECT DISTINCT `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΤΙΤΛΟΣ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                FROM `συγγράφει`
                JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` = `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                JOIN `ΦΟΡΕΑΣ` ON `συγγράφει`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ` = `ΦΟΡΕΑΣ`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ`
                WHERE `ΦΟΡΕΑΣ`.`ΚΩΔΙΚΟΣ ΦΟΡΕΑ` = %s """
    if instlen==1 and specific_inst!="9":
        f = "30000"
    elif instlen==2 or specific_inst=="9": f = "3000"
    kod_forea = f + str(int(specific_inst)+1)
    mycursor.execute(ar1,(kod_forea))
    result3 = mycursor.fetchall()
    global kod_arthr
    kod_arthr=[]
    al=[]
    c2=[]
    if len(result3)!=0:
        for i in result3:
            al.append(list(i.values()))
            kod_arthr.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
        for i in range(len(al)) :
            c2.append(al[i][0])
        what_to_do_with_article(kod_arthr,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου φορέα!!\n\n")

##Συνάρτηση που επιστρέφει επιστημονικά άρθρα που αντιστοιχούν σε ένα περιοδικό
def mag_to_art(specific_magazine):
    maglen=len(specific_magazine)
    ar2 = """SELECT `ΤΙΤΛΟΣ`, `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                FROM `περιλαμβάνεται`
                JOIN `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` ON  `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` =  `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ`.`ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ`
                WHERE `περιλαμβάνεται`.`ΚΩΔΙΚΟΣ ΠΕΡΙΟΔΙΚΟΥ`=%s"""
    if maglen==1 and specific_magazine!="9":
        p = "10000"
    elif maglen==2 or specific_magazine=="9": p = "1000"
    kod_per = p + str(int(specific_magazine)+1)
    mycursor.execute(ar2,(kod_per))
    result4 = mycursor.fetchall()
    global kod_arthr
    kod_arthr=[]
    al=[]
    c2=[]
    if len(result4)!=0:
        for i in result4:
            al.append(list(i.values()))
            kod_arthr.append(i.get("ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ"))
        for i in range(len(al)) :
            c2.append(al[i][0])
        what_to_do_with_article(kod_arthr,c2)
    else:print("\nΛυπούμαστε αλλά δεν υπάρχουν άρθρα του συγκεκριμένου περιοδικού!!\n\n")
##==============================================================================##

#### Συναρτήσεις που θα καλούνται στο βασικό μενού
##==============================================================================##
## Συνάρτηση που καλείται για αναζήτηση άρθρων με αφετηρία το επιστημονικό πεδίο
def from_subjects():
    subject = create_subject()
    print('\nΕΠΙΣΤΗΜΟΝΙΚΑ ΠΕΔΙΑ:')
    print('========================')
    j=1
    for i in subject:
        print(j,i)
        j=j+1
    while True:
        sub = input('\nΚωδικός επιστημονικού πεδίου:')
        if sub.isdigit() and int(sub) > 0 and int(sub) <= len(subject):
            sub = int(sub)-1
            print('\n\nοκ, ... Αναζήτηση άρθρων για πεδίο:', subject[sub])
            sub_to_art(subject[sub])
            break
        else:print("Πληκτρολγήστε έναν σωστό αριθμό")

## Συνάρτηση που καλείται για αναζήτηση άρθρων με αφετηρία τον συγγραφέα
def from_authors():
    author = create_author()
    print("\nΣΥΓΓΡΑΦΕΙΣ:")
    print('========================')
    j=1
    for i in author:
        print(j,i[0],i[1])
        j=j+1
    while True:
        aut = str(input('\nΚωδικός αρθρογράφου:'))
        if aut.isdigit() and int(aut) > 0 and int(aut) <= len(author):
            aut = int(aut)-1
            print("\nΤο προφίλ του συγγραφέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            full_auth(str(aut))
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του/της συγγραφέα:', author[aut][0], author[aut][1])
            aut_to_art(str(aut))
            break
        else:print("Πληκτρολγήστε έναν σωστό αριθμό")

## Συνάρτηση που καλείται για αναζήτηση άρθρων με αφετηρία τον φορέα
def from_institutions():
    institution = create_institutions()
    print('\nΦΟΡΕΙΣ:')
    print('========================')
    j=1
    for i in institution:
        print(j,i[0])
        j=j+1
    while True:
        ins = input('\nΚωδικός φορέα:')
        if ins.isdigit() and int(ins) > 0 and int(ins) <= len(institution):
            ins = int(ins)-1
            print("\nΤο προφίλ του φορέα που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            full_inst(str(ins))
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του φορέα:', institution[ins][0])
            ins_to_art(str(ins))
            break
        else:print("Πληκτρολγήστε έναν σωστό αριθμό")

## Συνάρτηση που καλείται για αναζήτηση άρθρων με αφετηρία το περιοδικό
def from_magazines():
    magazine = create_magazines()
    print('\nΠΕΡΙΟΔΙΚΑ:')
    print('========================')
    j=1
    for i in magazine:
        print(j,i[0])
        j=j+1
    while True:
        mag = input('\nΚωδικός περιοδικού:')
        if mag.isdigit() and int(mag) > 0 and int(mag) <= len(magazine):
            mag = int(mag)-1
            print("\nΤο προφίλ του περιοδικού που αναζητήσατε είναι το εξής:")
            print("=======================================================")
            full_magaz(str(mag))
            print("=======================================================")
            print('\nοκ, ... Αναζήτηση άρθρων του περιοδικού:', magazine[mag][0])
            mag_to_art(str(mag))
            break
        else:print("Πληκτρολγήστε έναν σωστό αριθμό")

def from_title():
    s1="select `ΤΙΤΛΟΣ`, `ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ` FROM `ΕΠΙΣΤΗΜΟΝΙΚΟ ΑΡΘΡΟ` "
    mycursor.execute(s1)
    a=mycursor.fetchall()
    c1=[]
    c2=[]
    for i in a:
        b=i.get('ΚΩΔΙΚΟΣ ΑΡΘΡΟΥ')
        c1.append(b)
        c2.append(i.get('ΤΙΤΛΟΣ'))
    what_to_do_with_article(c1,c2)

##==============================================================================##

def main_menu():
    while True:
        print("\n\nΑ Ρ Χ Ι Κ Ο   Μ Ε Ν Ο Υ\n")
        print("===========================")
        print("===========================\n")
        print("ΕΠΙΛΟΓΗ ΤΡΟΠΟΥ ΑΝΑΖΗΤΗΣΗΣ (enter για έξοδο)")
        print("==========================================")
        print("1: Αν θέλετε να αναζητείτε άμεσα δηλαδή να πληκτρολογείτε αυτό που ψάχνετε και όχι να επιλέγετε μέσω μιας λίστας\n")
        print("2: Αν θέλετε να αναζητείτε έμεσα δηλαδή να επιλέγετε μέσω μιας λίστας\n")
        print("3: Αν θέλετε να δείτε τα άρθρα που έχετε αποθηκεύσει στα αγαπημένα\n")
        print("4: Αν θέλετε να δείτε το ιστορικό τών άρθρων που έχετε επισκεφτεί (απο τα παλιά στα νεότερα)\n")
        ans = input("Πατήστε το αντίστοιχο νούμερο για να επιλέξετε τρόπο αναζήτησης: ")
        if ans == "1":
            print('\nΕΠΙΛΟΓΕΣ (enter για έξοδο)')
            print('1: Αναζήτηση άρθρου μέσω των επιστημονικών πεδίων')
            print('2: Αναζήτηση άρθρου μέσω των συγγραφέων')
            print('3: Αναζήτηση άρθρου μέσω των φορέων')
            print('4: Αναζήτηση άρθρου μέσω των περιοδικών')
            print('5: Αναζήτηση άρθρου μέσω λέξης κλειδιού')
            answer = input("Πατήστε το αντίστοιχο νούμερο για να επιλέξετε τρόπο αναζήτησης: ")
            if answer == "1":
                episthmoniko_pedio_search()
            elif answer == "2":
                author_search()
            elif answer == "3":
                foreas()
            elif answer == "4":
                magazine_search()
            elif answer == "5":
                key_words()
            elif answer == "":break
            else:print("Προσπαθήστε ξανά...\n")
        elif ans == "2":
            print('\nΕΠΙΛΟΓΕΣ (enter για έξοδο)')
            print('1: Αναζήτηση άρθρου μέσω των επιστημονικών πεδίων')
            print('2: Αναζήτηση άρθρου μέσω των συγγραφέων')
            print('3: Αναζήτηση άρθρου μέσω των φορέων')
            print('4: Αναζήτηση άρθρου μέσω των περιοδικών')
            print('5: Αναζήτηση χωρίς φίλτρο')
            answer = input("Πατήστε το αντίστοιχο νούμερο για να επιλέξετε τρόπο αναζήτησης: ")
            if answer == "1":
                from_subjects()
            elif answer == "2":
                from_authors()
            elif answer == "3":
                from_institutions()
            elif answer == "4":
                from_magazines()
            elif answer == "5":
                from_title()
            elif answer == "":break
            else:print("Προσπαθήστε ξανά...\n")
        elif ans == "3":
            open_favourites()
        elif ans == "4":
            open_history()
        elif ans == "":break
        else:print("Προσπαθήστε ξανά...\n")

main_menu()

# open_art("400001")


from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
import pandas as pd

from src.submission import make_submission
from src.utils import data_path
from sklearn import metrics, cross_validation

df = pd.read_csv(data_path('train.csv'))
df_test = pd.read_csv(data_path('test.csv'))

target = df['TARGET']
del df['TARGET']

def run_classifier(est_num, depth, n_f='auto'):
    clf = RandomForestClassifier(n_estimators=est_num, max_depth=depth, max_features=n_f)
    scores = cross_validation.cross_val_score(clf, df, target,
                                              cv=5, scoring='log_loss')
    print('est_num={}, depth={}, n_f={}'.format(str(est_num), str(depth), str(n_f)), scores.mean(), scores)
    (scores.mean(), scores, est_num, depth, n_f)

n_fs = [20, 40]
result = []

print(['auto'] + n_fs)

for depth in [5, 7, 8, 10, 15]:
    for n_f in ['auto'] + n_fs:
        for num in [10, 20, 30, 40, 50, 80, 100]:
            result.append(run_classifier(num, depth, n_f))

print("=======================================")
result.sort()
for r in result:
    mean, scores, est_num, depth, n_f = r
    print('est_num={}, depth={}, n_f={}'.format(str(est_num), str(depth), str(n_f)), mean, scores)

# clf.fit(df, target)

# print(len(df_test))
# print(len(clf.predict_proba(df_test)))
#
# prediction = [pred for _, pred in clf.predict_proba(df_test)]

# make_submission('baseline.csv', df_test['ID'], prediction)


import ccobra

class composite_model(ccobra.CCobraModel):

    def __init__(self, name='Ensemble-Model'):
        super(composite_model, self).__init__(
            name, ['syllogistic'], ['verify'])

        self.predictions = {}

    def get_predictions(self, identifier):
        if len(self.predictions) > 0:
            return
        predictions = []
        with open("prediction\\prediction.txt", "r") as f:
            for line in f:
                line = line.split(";")
                if int(line[1]) == identifier:
                    predictions.append((line[2], line[3].strip("\n")))
        # sort by accuracy
        predictions.sort()
        return eval(predictions[-1][1])

    def predict(self, item, **kwargs):
        predictions = self.get_predictions(item.identifier)
        return predictions[item.sequence_number]


"""
Code illustration: 10.03
Validation Modes Demo
Tkinter GUI Application Development Blueprints
"""

import tkinter as tk

class ValidateModeDemo():

    def __init__(self):
        self.root = tk.Tk()
        vcmd = (self.root.register(self.validate_data), '%V')

        # validate = none mode - will not call validate_data method ever.
        tk.Label(text='None').pack()
        tk.Entry(self.root, validate="none", validatecommand=vcmd).pack()

        # validate = focus mode - will call validate method_data on focusin and
        # focusout
        tk.Label(text='Focus').pack()
        tk.Entry(self.root, validate="focus", validatecommand=vcmd).pack()

        # validate = focusin mode - - will call validate_data method on focusin
        tk.Label(text='Focusin').pack()
        tk.Entry(self.root, validate="focusin", validatecommand=vcmd).pack()

        # validate = focusout mode - will call validate_data method on focusout
        tk.Label(text='Focus Out').pack()
        tk.Entry(self.root, validate="focusout", validatecommand=vcmd).pack()

        # validate = Key mode - will call validate_data method only when you
        # type something or edit the entry
        tk.Label(text='key').pack()
        tk.Entry(self.root, validate="key", validatecommand=vcmd).pack()

        # validate = all mode - will call validate_data method on focus and key
        # events
        tk.Label(text='all').pack()
        tk.Entry(self.root, validate="all", validatecommand=vcmd).pack()

        self.root.mainloop()

    def validate_data(self, v):
        print ('validate_data called via mode : {}'.format(v))
        # this is where you will validate your data and return True or False
        # depending on wether the data is valid or not
        # for now let us just return True for all cases.
        return True

app = ValidateModeDemo()


from django.urls import include, path
from rest_framework.documentation import include_docs_urls
from rest_framework.routers import SimpleRouter
from rest_framework_swagger.views import get_swagger_view
from api.views import CreatorViewSet

API_TITLE = 'asianstudiesbooks API'
API_DESC = 'A web API for creating, modifying and deleting Creators related to the Asian Studies Books Project.'

docs_view = include_docs_urls(
	title=API_TITLE,
	description=API_DESC
)

# Swagger view
schema_view = get_swagger_view(title=API_TITLE)

# Default view
'''
schema_view = get_schema_view(
	title=API_TITLE,
	# renderer_classes=[OpenAPIRenderer]
)
'''

router = SimpleRouter()
router.register(r'creators', CreatorViewSet, base_name='creators')
# urlpatterns = router.urls

# The API URLs are now determined automatically by the router.
urlpatterns = [
	path('', include(router.urls)),
	path('docs/', docs_view),
	path('swagger-docs/', schema_view)
	# path('schema/', schema_view)
]

'''
urlpatterns = [
	path('schema/', schema_view),
	path('sites/', views.SiteListAPIView.as_view(), name='site_api'),
	path('sites/<int:pk>/', views.SiteDetailAPIView.as_view(), name='site_detail_api'),
]
'''


# Jim R
# Write a program that prompts for a file name, then
# opens that file and reads through the file, and print
# the contents of the file in upper case.
# Use the file words.txt to produce the output below.

#Get filename from user
fname = input("Enter file name:")
fhandle = open(fname)

#loop through lines in the file, srip \n and capitalize, then print
for line in fhandle:
    line = line.rstrip().upper()
    print(line)