# pyerrors.input.utils API documentation

# pyerrors.input.utils

View Source

     1import re
     2"""Utilities for the input"""
     3
     4
     5def sort_names(ll):
     6    """Sorts a list of names of replika with searches for `r` and `id` in the replikum string.
     7    If this search fails, a fallback method is used,
     8    where the strings are simply compared and the first diffeing numeral is used for differentiation.
     9
    10    Parameters
    11    ----------
    12    ll: list
    13        list to sort
    14
    15    Returns
    16    -------
    17    ll: list
    18        sorted list
    19    """
    20    if len(ll) > 1:
    21        sorted = False
    22        r_pattern = r'r(\d+)'
    23        id_pattern = r'id(\d+)'
    24
    25        # sort list by id first
    26        if all([re.search(id_pattern, entry) for entry in ll]):
    27            ll.sort(key=lambda x: int(re.findall(id_pattern, x)[0]))
    28            sorted = True
    29        # then by replikum
    30        if all([re.search(r_pattern, entry) for entry in ll]):
    31            ll.sort(key=lambda x: int(re.findall(r_pattern, x)[0]))
    32            sorted = True
    33        # as the rearrangements by one key let the other key untouched, the list is sorted now
    34
    35        if not sorted:
    36            # fallback
    37            sames = ''
    38            for i in range(len(ll[0])):
    39                checking = ll[0][i]
    40                for rn in ll[1:]:
    41                    is_same = (rn[i] == checking)
    42                if is_same:
    43                    sames += checking
    44                else:
    45                    break
    46            print("Using prefix:", sames)
    47            ll.sort(key=lambda x: int(re.findall(r'\d+', x[len(sames):])[0]))
    48    return ll
    49
    50
    51def check_idl(idl, che):
    52    """Checks if list of configurations is contained in an idl
    53
    54    Parameters
    55    ----------
    56    idl : range or list
    57        idl of the current replicum
    58    che : list
    59        list of configurations to be checked against
    60
    61    Returns
    62    -------
    63    miss_str : str
    64        string with integers of which idls are missing
    65    """
    66    missing = []
    67    for c in che:
    68        if c not in idl:
    69            missing.append(c)
    70    # print missing configurations such that it can directly be parsed to slurm terminal
    71    if not (len(missing) == 0):
    72        print(len(missing), "configs missing")
    73        miss_str = str(missing[0])
    74        for i in missing[1:]:
    75            miss_str += "," + str(i)
    76        print(miss_str)
    77    return miss_str

def sort_names(ll): View Source

     6def sort_names(ll):
     7    """Sorts a list of names of replika with searches for `r` and `id` in the replikum string.
     8    If this search fails, a fallback method is used,
     9    where the strings are simply compared and the first diffeing numeral is used for differentiation.
    10
    11    Parameters
    12    ----------
    13    ll: list
    14        list to sort
    15
    16    Returns
    17    -------
    18    ll: list
    19        sorted list
    20    """
    21    if len(ll) > 1:
    22        sorted = False
    23        r_pattern = r'r(\d+)'
    24        id_pattern = r'id(\d+)'
    25
    26        # sort list by id first
    27        if all([re.search(id_pattern, entry) for entry in ll]):
    28            ll.sort(key=lambda x: int(re.findall(id_pattern, x)[0]))
    29            sorted = True
    30        # then by replikum
    31        if all([re.search(r_pattern, entry) for entry in ll]):
    32            ll.sort(key=lambda x: int(re.findall(r_pattern, x)[0]))
    33            sorted = True
    34        # as the rearrangements by one key let the other key untouched, the list is sorted now
    35
    36        if not sorted:
    37            # fallback
    38            sames = ''
    39            for i in range(len(ll[0])):
    40                checking = ll[0][i]
    41                for rn in ll[1:]:
    42                    is_same = (rn[i] == checking)
    43                if is_same:
    44                    sames += checking
    45                else:
    46                    break
    47            print("Using prefix:", sames)
    48            ll.sort(key=lambda x: int(re.findall(r'\d+', x[len(sames):])[0]))
    49    return ll

Sorts a list of names of replika with searches for `r` and `id` in the replikum string. If this search fails, a fallback method is used, where the strings are simply compared and the first diffeing numeral is used for differentiation.

###### Parameters

- ll (list): list to sort

###### Returns

- ll (list): sorted list

def check_idl(idl, che): View Source

    52def check_idl(idl, che):
    53    """Checks if list of configurations is contained in an idl
    54
    55    Parameters
    56    ----------
    57    idl : range or list
    58        idl of the current replicum
    59    che : list
    60        list of configurations to be checked against
    61
    62    Returns
    63    -------
    64    miss_str : str
    65        string with integers of which idls are missing
    66    """
    67    missing = []
    68    for c in che:
    69        if c not in idl:
    70            missing.append(c)
    71    # print missing configurations such that it can directly be parsed to slurm terminal
    72    if not (len(missing) == 0):
    73        print(len(missing), "configs missing")
    74        miss_str = str(missing[0])
    75        for i in missing[1:]:
    76            miss_str += "," + str(i)
    77        print(miss_str)
    78    return miss_str

Checks if list of configurations is contained in an idl

###### Parameters

- idl (range or list): idl of the current replicum
- che (list): list of configurations to be checked against

###### Returns

- miss_str (str): string with integers of which idls are missing