Used for the symbol table of a module.

  Used for the symbol table of a function.

  Used for the symbol table of a class.

  Used for annotations if ``from __future__ import annotations`` is active.

  Used for the symbol table of :keyword:`type` constructions.

  Used for the symbol table of :ref:`generic functions <generic-functions>`
  or :ref:`generic classes <generic-classes>`.

  Used for the symbol table of the bound, the constraint tuple or the
  default value of a single type variable in the formal sense, i.e.,
  a TypeVar, a TypeVarTuple or a ParamSpec object (the latter two do
  not support a bound or a constraint tuple).

  Return the type of the symbol table.  Possible values are members
  of the :class:`SymbolTableType` enumeration.

  .. versionchanged:: 3.12
     Added ``'annotation'``,  ``'TypeVar bound'``, ``'type alias'``,
     and ``'type parameter'`` as possible return values.

  .. versionchanged:: 3.13
     Return values are members of the :class:`SymbolTableType` enumeration.

     The exact values of the returned string may change in the future,
     and thus, it is recommended to use :class:`SymbolTableType` members
     instead of hard-coded strings.

  Return the table's identifier.

  Return the table's name.  This is the name of the class if the table is
  for a class, the name of the function if the table is for a function, or
  ``'top'`` if the table is global (:meth:`get_type` returns ``'module'``).
  For type parameter scopes (which are used for generic classes, functions,
  and type aliases), it is the name of the underlying class, function, or
  type alias. For type alias scopes, it is the name of the type alias.
  For :class:`~typing.TypeVar` bound scopes, it is the name of the ``TypeVar``.

  Return the number of the first line in the block this table represents.

  Return ``True`` if the locals in this table can be optimized.

  Return ``True`` if the block is a nested class or function.

  Return ``True`` if the block has nested namespaces within it.  These can
  be obtained with :meth:`get_children`.

  Return a view object containing the names of symbols in the table.
  See the :ref:`documentation of view objects <dict-views>`.

  Lookup *name* in the table and return a :class:`Symbol` instance.

  Return a list of :class:`Symbol` instances for names in the table.

  Return a list of the nested symbol tables.

  Return a tuple containing names of parameters to this function.

  Return a tuple containing names of locals in this function.

  Return a tuple containing names of globals in this function.

  Return a tuple containing names of explicitly declared nonlocals in this function.

  Return a tuple containing names of :term:`free (closure) variables <closure variable>`
  in this function.

  Return a tuple containing names of :term:`cell variables <closure variable>` in this table.

  .. versionadded:: 3.15

  Return a tuple containing the names of method-like functions declared
  in the class.

  Here, the term 'method' designates *any* function defined in the class
  body via :keyword:`def` or :keyword:`async def`.

  Functions defined in a deeper scope (e.g., in an inner class) are not
  picked up by :meth:`get_methods`.

  For example:

  .. testsetup:: symtable.Class.get_methods

     import warnings
     context = warnings.catch_warnings()
     context.__enter__()
     warnings.simplefilter("ignore", category=DeprecationWarning)

  .. testcleanup:: symtable.Class.get_methods

     context.__exit__()

  .. doctest:: symtable.Class.get_methods

     >>> import symtable
     >>> st = symtable.symtable('''
     ... def outer(): pass
     ...
     ... class A:
     ...    def f():
     ...        def w(): pass
     ...
     ...    def g(self): pass
     ...
     ...    @classmethod
     ...    async def h(cls): pass
     ...
     ...    global outer
     ...    def outer(self): pass
     ... ''', 'test', 'exec')
     >>> class_A = st.get_children()[2]
     >>> class_A.get_methods()
     ('f', 'g', 'h')

  Although ``A().f()`` raises :exc:`TypeError` at runtime, ``A.f`` is still
  considered as a method-like function.

  .. deprecated-removed:: 3.14 3.16

  Return the symbol's name.

  Return ``True`` if the symbol is used in its block.

  Return ``True`` if the symbol is created from an import statement.

  Return ``True`` if the symbol is a parameter.

  Return ``True`` if the symbol is a type parameter.

  .. versionadded:: 3.14

  Return ``True`` if the symbol is global.

  Return ``True`` if the symbol is nonlocal.

  Return ``True`` if the symbol is declared global with a global statement.

  Return ``True`` if the symbol is local to its block.

  Return ``True`` if the symbol is annotated.

  .. versionadded:: 3.6

  Return ``True`` if the symbol is referenced in its block, but not assigned
  to.

  Return ``True`` if the symbol is referenced but not assigned in a nested block.

  .. versionadded:: 3.15

  Return *True* if a class-scoped symbol is free from
  the perspective of a method.

  Consider the following example::

     def f():
         x = 1  # function-scoped
         class C:
             x = 2  # class-scoped
             def method(self):
                 return x

  In this example, the class-scoped symbol ``x`` is considered to
  be free from the perspective of ``C.method``, thereby allowing
  the latter to return *1* at runtime and not *2*.

  .. versionadded:: 3.14

  Return ``True`` if the symbol is assigned to in its block.

  Return ``True`` if the symbol is a comprehension iteration variable.

  .. versionadded:: 3.14

  Return ``True`` if the symbol is a cell in an inlined comprehension.

  .. versionadded:: 3.14

  Return ``True`` if name binding introduces new namespace.

  If the name is used as the target of a function or class statement, this
  will be true.

  For example::

     >>> table = symtable.symtable("def some_func(): pass", "string", "exec")
     >>> table.lookup("some_func").is_namespace()
     True

  Note that a single name can be bound to multiple objects.  If the result
  is ``True``, the name may also be bound to other objects, like an int or
  list, that does not introduce a new namespace.

  Return a list of namespaces bound to this name.

  Return the namespace bound to this name. If more than one or no namespace
  is bound to this name, a :exc:`ValueError` is raised.