Improve compatibility for python syntax in AST rewrite

[vineetg3]

Resolve #222

[vineetg3]

Bug fix: Since we need to remove init_pydough_context, the updated deco list needs to be sent.

[vineetg3]

Resolve #222

This PR modifies the AST visitor to support more python syntax. Here are examples of syntax that is supported now:
Here’s the updated list with meaningful headings instead of the test function names:

1. Variable-Length Arguments with *args and **kwargs: Handling variable-length arguments and keyword arguments in function definitions.
   Ex:

   def impl(*args, **kwargs):
       terms = {}

2. Tuple Unpacking: Assigning multiple values from a tuple in a single statement.
   Ex:

   start, end = (1992, 1994)

3. Unpacking Nested Structures: Unpacking complex nested structures like lists or tuples.
   Ex:

   a, (b, c) = ["GERMANY", ["FRANCE", "ARGENTINA"]]

4. Dynamic Pairing with zip: Unpacking paired values dynamically within an iterable using zip.
   Ex:

   for i, j in zip(range(5), range(1992, 1997)):
       terms[f"c{i}"] = COUNT(orders.WHERE(YEAR(order_date) == j))

5. Context Managers with with: Managing multiple resources using a with block and importing modules with aliases.
   Ex:

   with tf.TemporaryFile() as tf_handle1, tf.TemporaryFile() as tf_handle2:
       tf_handle1.write(b"Canada")

6. Exception Handling: Using try, except, and finally blocks to handle exceptions.
   Ex:

   try:
       raise Exception("Canada")

7. Object-Oriented Programming: Using classes to encapsulate logic and data.
   Ex:

   class Customer:
       def __init__(self, countries):
           self._countries = countries

8. Dynamic Term Generation with Loops: Using a loop and dictionary to dynamically generate terms.
   Ex:

   for i in range(3):
       terms[f"interval_{i}"] = COUNT(
           customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000))
       )

9. Reusable Logic with Functions: Defining reusable logic to generate terms using regular functions.
   Ex:

   def interval_n(n):
       return COUNT(customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000)))

10. Shadowing Variables in Functions: Using function arguments that overlap with collection fields.
    Ex:

    def interval_n(n, name="test"):
        return COUNT(customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000)))

11. Lambda Functions for Concise Logic: Using a lambda function for one-line anonymous logic.
    Ex:

    interval_n = lambda n: COUNT(
        customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000))
    )

12. Dictionary Comprehensions: Dynamically populating dictionaries using comprehensions.
    Ex:

    terms.update(
        {
            f"interval_{i}": COUNT(
                customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000))
            )
            for i in range(3)
        }
    )

13. List Comprehensions: Generating and extending lists using comprehensions.
    Ex:

    terms.extend(
        [
            COUNT(customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000)))
            for i in range(3)
        ]
    )

14. Set Comprehensions for Unique Terms: Generating unique terms with a set comprehension and sorting.
    Ex:

    terms.extend(
        set(
            {
                COUNT(customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000)))
                for i in range(3)
            }
        )
    )

[knassre-bodo]

Looks fantastic @vineetg3 !!! Just a few things before I'll approve.

[knassre-bodo]

Resolve #222

This PR modifies the AST visitor to support more python syntax. Here are examples of syntax that is supported now: Here’s the updated list with meaningful headings instead of the test function names:

1. Variable-Length Arguments with *args and **kwargs: Handling variable-length arguments and keyword arguments in function definitions.
   Ex:

   def impl(*args, **kwargs):
       terms = {}

2. Tuple Unpacking: Assigning multiple values from a tuple in a single statement.
   Ex:

   start, end = (1992, 1994)

3. Unpacking Nested Structures: Unpacking complex nested structures like lists or tuples.
   Ex:

   a, (b, c) = ["GERMANY", ["FRANCE", "ARGENTINA"]]

4. Dynamic Pairing with zip: Unpacking paired values dynamically within an iterable using zip.
   Ex:

   for i, j in zip(range(5), range(1992, 1997)):
       terms[f"c{i}"] = COUNT(orders.WHERE(YEAR(order_date) == j))

5. Context Managers with with: Managing multiple resources using a with block and importing modules with aliases.
   Ex:

   with tf.TemporaryFile() as tf_handle1, tf.TemporaryFile() as tf_handle2:
       tf_handle1.write(b"Canada")

6. Exception Handling: Using try, except, and finally blocks to handle exceptions.
   Ex:

   try:
       raise Exception("Canada")

7. Object-Oriented Programming: Using classes to encapsulate logic and data.
   Ex:

   class Customer:
       def __init__(self, countries):
           self._countries = countries

8. Dynamic Term Generation with Loops: Using a loop and dictionary to dynamically generate terms.
   Ex:

   for i in range(3):
       terms[f"interval_{i}"] = COUNT(
           customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000))
       )

9. Reusable Logic with Functions: Defining reusable logic to generate terms using regular functions.
   Ex:

   def interval_n(n):
       return COUNT(customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000)))

10. Shadowing Variables in Functions: Using function arguments that overlap with collection fields.
    Ex:

    def interval_n(n, name="test"):
        return COUNT(customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000)))

11. Lambda Functions for Concise Logic: Using a lambda function for one-line anonymous logic.
    Ex:

    interval_n = lambda n: COUNT(
        customers.WHERE(MONOTONIC(n * 1000, acctbal, (n + 1) * 1000))
    )

12. Dictionary Comprehensions: Dynamically populating dictionaries using comprehensions.
    Ex:

    terms.update(
        {
            f"interval_{i}": COUNT(
                customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000))
            )
            for i in range(3)
        }
    )

13. List Comprehensions: Generating and extending lists using comprehensions.
    Ex:

    terms.extend(
        [
            COUNT(customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000)))
            for i in range(3)
        ]
    )

14. Set Comprehensions for Unique Terms: Generating unique terms with a set comprehension and sorting.
    Ex:

    terms.extend(
        set(
            {
                COUNT(customers.WHERE(MONOTONIC(i * 1000, acctbal, (i + 1) * 1000)))
                for i in range(3)
            }
        )
    )

Btw, make sure to include this comment of yours in the merge commit. These are FANTASTIC details to include.

[knassre-bodo]

LGTM!