Python code patterns: elegant way of trying different methods until one suceeds?

I'm trying to extract informations from an HTML page, like its last modification date, in a context where there are more than one way of declaring it, and those ways use non-uniform data (meaning a simple loop over fetched data is not possible).

The ugly task is as follow:

def get_date(html):
  date = None
  # Approach 1
  time_tag = html.find("time", {"datetime": True})
  if time_tag:
    date = time_tag["datetime"]
  if date:
    return date

  # Approach 2
  mod_tag = html.find("meta", {"property": "article:modified_time", "content": True})
  if mod_tag:
    date = mod_tag["content"]
  if date:
    return date
  
  # Approach 3
  div_tag = html.find("div", {"class": "dateline"})
  if div_tag:
    date = div_tag.get_text()
  if date:
    return date
  
  # Approach n
  # ...

  return date

I wonder if Python doesn't have some concise and elegant way of achieving this through a `while" logic, in order to run fast, be legible and maintenance-friendly:

def method_1(html):
  test = html.find("time", {"datetime": True})
  return test["datetime"] if test else None

def method_2(html):
  test = html.find("meta", {"property": "article:modified_time", "content": True})
  return test["content"] if test else None

def method_3(html):
  test = html.find("div", {"class": "dateline"})
  return test.get_text() if test else None

...

def get_date(html):
  date = None
  bag_of_methods = [method_1, method_2, method_3, ...]

  i = 0
  while not date and i < len(bag_of_methods):
    date = bag_of_methods[i](html)
    i += 1

  return date

I can make that work right now by turning each approach from the first snippet in a function, append all functions to the bag_of_methods iterable and run them all until one works.

However, those functions would be 2 lines each and will not be reused later in the program, so it just seems like it's adding more lines of code and polluting the namespace for nothing.

Is there a better way of doing this ?

To keep the namespace clean, you can define the method_x functions inside your get_date:

def get_date(HTML):

  def method_1(HTML):
    test = html.find("time", {"datetime": True})
    return test["datetime"] if test else None

  def method_2(HTML):
    test = html.find("meta", {"property": "article:modified_time", "content": True})
    return test["content"] if test else None

  date = None
  bag_of_methods = [method_1, method_2, ...]
  #...

I also feel hinky when I see a while loop looping over a defined sequence, so I'd be tempted to rewrite with a for and a break. Also, beware that certain types can evaluate to False in a boolean context, so you might want to re-write the escape condition using is None:

date = None

for test in bag_of_methods:
    date = test(html)
    if date is not None:
        break

Also, you can utilize the short-circuiting property of or:

date = method_1(html) or method_2(html) or method_3(html)
if date:
  return date
else:
  return None

Execution will go from left to right, and will stop as soon as something returns a value that evaluates to True - although this falls into the same trap if one of your dates somehow evaluates to False

Here is something reusable:

class CallChain:
    def __init__(self, *methods):
        self.methods = methods
        
    def __call__(self, *args, **kwargs):
        for method in self.methods:
            result = method(*args, **kwargs)
            if result is not None:
                return result
        return False

To use it:

get_date = CallChain(method_1, method_2, method_3)
date = get_date(html)

You can use this class for other method chains as well.

A different implementation of this idea is to use enclosure:

def call_chain(*methods):
    def call_it(*args, **kwargs):
        for method in methods:
            result = method(*args, **kwargs)
            if result is not None:
                return result
        return False
    return call_it

To use it:

get_date = call_chain(method_1, method_2, method_3)
date = get_date(html)