Optimize code
```
from ENM_class import EnmCli

from parser_utils import parse_eutran_cells, parse_nodeb_pars, parse_nodeb_mo_pars, parse_fea, combine_fea, parse_cosector, clean_cell, clean_band, delete_region, parse_anr_rels
from Baseline import Baseline, compare
from file_write import stat, baseline_write
from collections import Counter
from dotenv import load_dotenv
from remove_old_files import remove_old_files
from mail import send_email
from upload_reports import upload_reports
# from datetime import datetime
load_dotenv('.env')

    command_map = {
        'UtranFreqRelation_prio3_base': ('UtranFreqRelation_prio3_par', Baseline.UtranFreqRelation_prio3_base),
        'UtranFreqRelation_prio4_base': ('UtranFreqRelation_prio4_par', Baseline.UtranFreqRelation_prio4_base),
        'GeranFreqGroupRelation_900_base': ('GeranFreqGroupRelation_900_par', Baseline.GeranFreqGroupRelation_900_base),
        'GeranFreqGroupRelation_1800_base': ('GeranFreqGroupRelation_1800_par', Baseline.GeranFreqGroupRelation_1800_base),
        'UeMeasControl_base': ('UeMeasControl_par', Baseline.UeMeasControl_base),
    }

def enm_main(mo_type, enm):

    if mo_type == 'BbuENodeBFunctionFea_base':
        enm_bbu_feature = EnmCli.execute_cli_command('BBU_ENodeBFunction_fea', enm)
        bbu_feature_sort = parse_fea(enm_bbu_feature)
        bbu_features = combine_fea(bbu_feature_sort, len(EnmCli.BbuENodeBFunctionFea))
        if bbu_features:
            return compare(bbu_features, Baseline.BbuENodeBFunctionFea_base)
    elif mo_type == 'DusENodeBFunctionFea_base':
        enm_dus_feature = EnmCli.execute_cli_command('DUS_ENodeBFunction_fea', enm)
        dus_feature_sort = parse_fea(enm_dus_feature)
        dus_features = combine_fea(dus_feature_sort, len(EnmCli.DusENodeBFunctionFea))
        if dus_features:
            return compare(dus_features, Baseline.DusENodeBFunctionFea_base)
    elif mo_type == 'ENodeBFunction_base':
        enm_enodebfunction = EnmCli.execute_cli_command('ENodeBFunction_par', enm)
        enodebfunction = parse_nodeb_pars(enm_enodebfunction, EnmCli.ENodeBFunction[-1])
        if enodebfunction:
            return compare(enodebfunction, Baseline.ENodeBFunction_base)
    else:
        command, baseline = command_map[mo_type]
        enm_output = EnmCli.execute_cli_command(command, enm)
        list_name = command.split('_')[0]
        parsed_output = parse_nodeb_mo_pars(enm_output, getattr(EnmCli, list_name)[-1], 'Sub_EUtranCellFDD')
        cleaned_output = clean_cell(parsed_output)
        separated_output = delete_region(cleaned_output, 'Shymkent') if 'shym' not in mo_type else cleaned_output
        if separated_output:
            return compare(separated_output, baseline)

base = [name for name, obj in vars(Baseline).items() if isinstance(obj, dict)]

inconslist = []
parslist = []
total_delta = []
output1 = [enm_main(b, 'ENM_1') for b in base]
output2 = [enm_main(b, 'ENM_2') for b in base]
output = output1 + output2

for part in output:
    try:
        incon = part[-1]
    except TypeError:
        continue
    try:
        par = part[1]
    except TypeError:
        continue
    try:
        delta = part[0]
    except TypeError:
        continue
    inconslist.append(incon)
    parslist.append(par)
    total_delta = total_delta + delta
total_pars = Counter()
total_incons = Counter()
for incons in inconslist:
    total_incons.update(incons)
for pars in parslist:
    total_pars.update(pars)

sorted_baseline_pars = dict(sorted(total_pars.items()))
sorted_baseline_incons = dict(sorted(total_incons.items()))
sorted_baseline_delta = sorted(total_delta, key=lambda d: (d.get('dictionary_item_added', {}).get("root['Region']"), d.get('dictionary_item_added', {}).get("root['ERBS_Name']")), )

remove_old_files()

stat(sorted_baseline_pars, sorted_baseline_incons, "Statistics/Baseline_Statistics.txt")

baseline_write(sorted_baseline_incons, sorted_baseline_delta)
```