code: def make_dataclass(
      cls_name,
      fields,
      *,
      bases=(),
      namespace=None,
      init=True,
      repr=True,
      eq=True,
      order=False,
      unsafe_hash=False,
      frozen=False,
  ):
      """Return a new dynamically created dataclass.
  
      The dataclass name will be 'cls_name'.  'fields' is an iterable
      of either (name), (name, type) or (name, type, Field) objects. If type is
      omitted, use the string 'typing.Any'.  Field objects are created by
      the equivalent of calling 'field(name, type [, Field-info])'.
  
        C = make_dataclass('C', ['x', ('y', int), ('z', int, field(init=False))], bases=(Base,))
  
      is equivalent to:
  
        @dataclass
        class C(Base):
            x: 'typing.Any'
            y: int
            z: int = field(init=False)
  
      For the bases and namespace parameters, see the builtin type() function.
  
      The parameters init, repr, eq, order, unsafe_hash, and frozen are passed to
      dataclass().
      """
  
      if namespace is None:
          namespace = {}
      else:
          # Copy namespace since we're going to mutate it.
          namespace = namespace.copy()
  
      # While we're looking through the field names, validate that they
      # are identifiers, are not keywords, and not duplicates.
      seen = set()
      anns = {}
      for item in fields:
          if isinstance(item, str):
              name = item
              tp = "typing.Any"
          elif len(item) == 2:
              (
                  name,
                  tp,
              ) = item
          elif len(item) == 3:
              name, tp, spec = item
              namespace[name] = spec
          else:
              raise TypeError(f"Invalid field: {item!r}")
  
          if not isinstance(name, str) or not name.isidentifier():
              raise TypeError(
                  f"Field names must be valid identifers: {name!r}"
              )
          if keyword.iskeyword(name):
              raise TypeError(
                  f"Field names must not be keywords: {name!r}"
              )
          if name in seen:
              raise TypeError(f"Field name duplicated: {name!r}")
  
          seen.add(name)
          anns[name] = tp
  
      namespace["__annotations__"] = anns
      # We use `types.new_class()` instead of simply `type()` to allow dynamic creation
      # of generic dataclassses.
      cls = types.new_class(
          cls_name, bases, {}, lambda ns: ns.update(namespace)
      )
      return dataclass(
          cls,
          init=init,
          repr=repr,
          eq=eq,
          order=order,
          unsafe_hash=unsafe_hash,
          frozen=frozen,
      )
  
imports: import re
  import sys
  import copy
  import types
  import inspect
  import keyword
label_desc: Use image node_id 29 for calling a global function with example usage: make_dataclass(cls_name, fields) and returns: dataclass