code: def make_dataclass(
      cls_name,
      fields,
      *,
      bases=(),
      namespace=None,
      init=True,
      repr=True,
      eq=True,
      order=False,
      unsafe_hash=False,
      frozen=False,
      match_args=True,
      kw_only=False,
      slots=False,
      weakref_slot=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 = {}
  
      # While we're looking through the field names, validate that they
      # are identifiers, are not keywords, and not duplicates.
      seen = set()
      annotations = {}
      defaults = {}
      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
              defaults[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 identifiers: {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)
          annotations[name] = tp
  
      # Update 'ns' with the user-supplied namespace plus our calculated values.
      def exec_body_callback(ns):
          ns.update(namespace)
          ns.update(defaults)
          ns["__annotations__"] = annotations
  
      # We use `types.new_class()` instead of simply `type()` to allow dynamic creation
      # of generic dataclasses.
      cls = types.new_class(cls_name, bases, {}, exec_body_callback)
  
      # Apply the normal decorator.
      return dataclass(
          cls,
          init=init,
          repr=repr,
          eq=eq,
          order=order,
          unsafe_hash=unsafe_hash,
          frozen=frozen,
          match_args=match_args,
          kw_only=kw_only,
          slots=slots,
          weakref_slot=weakref_slot,
      )
  
imports: import re
  import sys
  import copy
  import types
  import inspect
  import keyword
  import builtins
  import functools
  import itertools
  import abc
  import _thread
  from types import FunctionType, GenericAlias
label_desc: Use image node_id 37 for calling a global function with example usage: make_dataclass(cls_name, fields) and returns: dataclass