How to use the genie.utils.timeout.Timeout function in genie

None
    """
    slots = spa.split("/")
    reqs = R(
        [
            "slot",
            slots[0],
            "(?P.*)",
            "(?P.*)",
            "subslot",
            slots[1],
            "(?P.*)",
        ]
    )

    timeout = Timeout(max_time, check_interval)
    while timeout.iterate():
        try:
            out = device.parse("show platform")
        except SchemaEmptyParserError:
            timeout.sleep()
            continue

        found = find([out], reqs, filter_=False, all_keys=True)
        if not found:
            return True
        timeout.sleep()

    return False

''' Verify module serial number is matched with expected number

        Args:
            device (`obj`): Device object
            installed_packages (`list`): List of packages to verify that exist
            max_time (`int`): Maximum time to wait while checking for pies installed
                              Default 300 seconds (Optional)
          check_interval (`int`): Time interval while checking for pies installed
                                  Default 30 seconds (Optional)

        Returns:
            result (`bool`): Verified result
    '''

    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():

        active_packages = device.api.get_current_active_pies()

        # Trim out active_packages
        if active_packages:
            active_packages = [item.split(":")[1] for item in active_packages]

        if set(installed_packages).intersection(active_packages):
            log.info("Installed packages {} present under 'Active Packages'".\
                    format(installed_packages))
            return True

        log.warning("Installed packages {} *not* present in 'Active Packages'"
                    "\nRe-checking after {} seconds...".\

"""
    route = route.split('/')
    if len(route) > 1:
        route = '{} {}'.format(route[0], device.api.int_to_mask(int(route[1])))
    else:
        route = route[0]

    patterns = ['No Label', 'implicit-null', 'Pop Label', 'none', '']
    if none_pattern:
        patterns.extend(none_pattern)

    cmd1 = "show ip route {}".format(route)
    cmd2 = "show ip cef {}".format(route)
    cmd3 = "show mpls forwarding-table {}".format(route)

    timeout = Timeout(max_time, check_interval)
    while timeout.iterate():
        result = True
        table = PrettyTable()
        table.field_names = ['RIB (INTF)', 'RIB (NH)', 'RIB (LABEL)', 
                             'FIB (INTF)', 'FIB(NH) ', 'FIB (LABEL)', 
                             'FIB (LOCAL LABEL)', 'LFIB (INTF)', 'LFIB(NH)', 
                             'LFIB (LABEL)', 'LFIB (LOCAL LABEL)', 'PASS/FAIL']

        try:
            out1 = device.parse(cmd1)
        except Exception as e:
            log.error("Failed to parse '{}':\n{}".format(cmd1, e))
            result = False
            timeout.sleep()
            continue

def is_ospf_neighbor_established_on_interface(device, interface, max_time=30, check_interval=10):
    """ Verify OSPF is established on the interface

        Args:
            device (`obj`): Device object
            interface (`str`): Interface name
            max_time (`int`): Maximum wait time
            check_interval (`int`): Check interval

        Returns:
            result (`bool`): Verified result
    """
    cmd = "show ip ospf neighbor"
    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():
        try:
            out = device.parse(cmd)
        except Exception as e:
            log.error("Failed to parse '{cmd}': {e}".format(cmd=cmd, e=e))
            timeout.sleep()
            continue

        if interface in out.get('interfaces', {}):
            log.info("OSPF interface {intf} is established".format(intf=interface))
            return True

        timeout.sleep()

    return False

[
            "vrf",
            "(?P{vrf})".format(vrf=vrf),
            "address_family",
            "(?P.*)",
            "prefix",
            "(?P.*)",
            "output_chain",
            "tag_midchain",
            "(?P.*)",
            "label",
            "(?P<label>.*)"
        ]
    )

    timeout = Timeout(max_time, check_interval)
    while timeout.iterate():
        try:
            out = device.parse('show ip cef vrf {vrf} {prefix} internal'.format(vrf=vrf, prefix=prefix))
        except SchemaEmptyParserError:
            log.info("Parser output is empty")
            timeout.sleep()
            continue

        stack_copy = list(stack)
        found = find([out], reqs, filter_=False, all_keys=True)
        if found:
            for label in found[0][0]:
                for stack_item in stack_copy:
                    if str(stack_item) in label:
                        # If item found, break to prevent else block from running
                        stack_copy.remove(stack_item)
</label>

"""Verify 'show ospf database network lsa-id {ipaddress} detail' attached-router contains expected_id

    Args:
        device ('obj'): device to use
        expected_id ('str'): expected router id
        ipaddress ('str'): address to use in show command
        max_time ('int'): Maximum time to keep checking
        check_interval ('int'): How often to check

    Raise: None

    Returns: Boolean

    """

    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():
        out = None
        try:        
            out = device.parse(f'show ospf database network lsa-id {ipaddress} detail')   
        except SchemaEmptyParserError:
            timeout.sleep()
            continue

        if expected_id in out.q.get_values("attached-router"):           
            return True
        else:
            timeout.sleep()
            continue

    return False

device ('obj'): device to use
            expected_interface ('str'): Interface to use
            expected_interface_type ('str'): Interface type
            expected_state ('str'): Interface state
            extensive ('boolean'): Flag for extensive command
            max_time ('int'): Maximum time to keep checking
            check_interval ('int'): How often to check
            expected_hello_interval ('str'): Expected hello interval

        Returns:
            True/False

        Raises:
            N/A
    """
    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():
        out = None
        try:
            if extensive:
                out = device.parse('show ospf interface extensive')
            else:
                out = device.parse('show ospf interface')
        except SchemaEmptyParserError:
            timeout.sleep()
            continue

        # {
        # "ospf-interface-information": {
        #     "ospf-interface": [
        #         {

"""Verify 'show ospf route network extensive'

    Args:
        device ('obj'): device to use
        expected_interface ('str'): address to verify
        expected_path_type ('str'): path to verify
        max_time ('int'): Maximum time to keep checking
        check_interval ('int'): How often to check

    Raise: None

    Returns: Boolean

    """

    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():
        out = None
        try:

            out = device.parse('show ospf3 route network extensive')
        except SchemaEmptyParserError:
            timeout.sleep()
            continue

        #{'ospf-route-entry': 
        #   {'address-prefix': '1.1.1.1/32', 
        #                      'route-path-type': 'Intra', 'route-type': 'Network', 
        #                      'next-hop-type': 'IP', 'interface-cost': '0', 
        #                      'ospf-next-hop': {'next-hop-name': {'interface-name': 'lo0.0'}}, 
        #                      'ospf-area': '0.0.0.0', 

check_interval=10):
    """Verify 'show ospf database' lsa-types contains expected_types

    Args:
        device ('obj'): device to use
        expected_types ('str'): types to verify
        max_time ('int'): Maximum time to keep checking. Defaults to 60
        check_interval ('int'): How often to check. Defaults to 10

    Raise: None

    Returns: Boolean

    """

    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():
        out = None
        try:
            
            out = device.parse('show ospf database')
        except SchemaEmptyParserError:
            timeout.sleep()
            continue


        found_types = out.q.get_values("lsa-type")

        if set(found_types).issuperset(set(expected_types)):
            return True
        else:

device (`obj`): Device object
            policy (`str`): Policy name
            expected_bsid (`int`): Expected Binding SID
            expected_mode (`str`): Expected allocation mode
            expected_state (`str`): Expected binding state
            policy_dict (`dict`): Policy dict from parser output 
                IOSXE Parser - ShowSegmentRoutingTrafficEngPolicy
                cmd - show segment-routing traffic-eng policy all
            max_time (`int`): Max time, default: 30
            check_interval (`int`): Check interval, default: 10
        Returns
            result (`bool`): Verified result
            sid (`int`): Binding sid
    """
    cmd = 'show segment-routing traffic-eng policy name {policy}'.format(policy=policy)
    timeout = Timeout(max_time, check_interval)

    while timeout.iterate():

        if policy_dict is None:
            try:
                out = device.parse(cmd)
            except Exception as e:
                log.error("Failed to parse '{cmd}': {e}".format(cmd=cmd, e=e))
                timeout.sleep()
                continue
        else:
            out = policy_dict

        bsid_dict = out.get(policy, {}).get('attributes', {}).get('binding_sid', {})

        if bsid_dict: