Python namedtuple Implementation Challenge

This challenge asks you to replicate the functionality of Python's built-in collections.namedtuple. You'll create a factory function that generates new classes, similar to tuples, but with named fields accessible by both index and attribute name. This is useful for creating lightweight, immutable objects that are more readable than regular tuples.

Problem Description

Your task is to implement a function, let's call it my_namedtuple, that acts as a factory for creating new "named tuple" classes.

Requirements:

1. The my_namedtuple function should accept two arguments:

   • typename: A string representing the name of the new class to be created.
   • field_names: A string of space-separated field names, or an iterable (like a list or tuple) of strings representing the field names.

2. The function should return a new class.

3. Instances of this new class should behave like tuples:

   • They should be immutable.
   • Their values should be accessible by index.

4. Instances should also allow access to their values by the specified field names as attributes (e.g., instance.field_name).

5. The class should have a meaningful __repr__ method that displays the typename and the named fields with their values.

6. The class should support iteration over its values in the order of the field_names.

7. The class should provide a way to get the field names (e.g., as a tuple).

Expected Behavior:

When you create a new class using my_namedtuple('Point', ['x', 'y']), you should be able to:

• Instantiate it: p = Point(1, 2)
• Access by index: p[0] should be 1, p[1] should be 2.
• Access by name: p.x should be 1, p.y should be 2.
• Check immutability: Attempting p.x = 5 should raise an AttributeError.
• Get the representation: repr(p) should look something like Point(x=1, y=2).
• Iterate: for val in p: print(val) should print 1 then 2.
• Get field names: Accessing a special attribute (e.g., Point._fields) should return ('x', 'y').

Edge Cases:

• Handling of field_names as a single string versus an iterable.
• Ensuring no name collisions if typename or field_names conflict with Python keywords or built-in method names (though a perfect solution for this is complex; focus on basic validity and common cases).
• What happens if the number of arguments passed during instantiation doesn't match the number of field_names? (Standard tuple behavior or a clear error is expected).

Examples

Example 1:

# Assuming my_namedtuple is defined
Point = my_namedtuple('Point', 'x y')
p = Point(10, 20)

print(p.x)
print(p[1])
print(repr(p))
print(Point._fields)

# Expected Output:
# 10
# 20
# Point(x=10, y=20)
# ('x', 'y')

Explanation: We create a Point class with fields 'x' and 'y'. We then instantiate it and demonstrate access via attribute name (p.x), index (p[1]), a human-readable representation (repr(p)), and retrieving the defined field names (Point._fields).

Example 2:

# Assuming my_namedtuple is defined
Color = my_namedtuple('Color', ['red', 'green', 'blue'])
c = Color(255, 128, 0)

print(c[0])
print(c.green)
print(list(c))

# Expected Output:
# 255
# 128
# [255, 128, 0]

Explanation: Here, field_names is provided as a list. We demonstrate accessing values by index and attribute name, and also converting the named tuple instance to a list via iteration.

Example 3: (Error Handling - Illustrative)

# Assuming my_namedtuple is defined
Book = my_namedtuple('Book', 'title author')

try:
    b = Book("The Hitchhiker's Guide to the Galaxy") # Missing author
except TypeError as e:
    print(e)

try:
    b = Book("Dune", "Frank Herbert", "Sci-Fi") # Too many arguments
except TypeError as e:
    print(e)

# Expected Output:
# Book() missing 1 required positional argument: 'author'
# Book() takes 2 positional arguments but 3 were given

Explanation: This example illustrates the expected TypeError when the number of arguments provided during instantiation does not match the number of field names.

Constraints

• The typename must be a valid Python identifier.
• The field_names must result in valid Python identifiers for each field. (e.g., "1field" is invalid).
• The generated class must be immutable.
• The generated class must be distinguishable from standard tuples (e.g., it should have a specific __class__ attribute or be a distinct type).
• Your my_namedtuple function should not use collections.namedtuple or any other direct reimplementations of named tuples. You should build the class dynamically.
• The number of positional arguments passed to the constructor of the generated class must match the number of field_names.
• The generated class should have a _fields attribute containing a tuple of field names.

Notes

Consider using Python's dynamic class creation capabilities. You'll need to define the __new__ or __init__ method for the generated class to store the values, and you'll likely want to implement __getattr__ and __setattr__ (or override __setattr__ to raise errors for immutability). Also, think about how to generate the __repr__ and __iter__ methods dynamically.