class_docstr: Class that defines methods for generating code from schemas
  
  Parameters
  ----------
  classname : string
      The name of the class to generate
  schema : dict
      The dictionary defining the schema class
  rootschema : dict (optional)
      The root schema for the class
  basename : string or list of strings (default: "SchemaBase")
      The name(s) of the base class(es) to use in the class definition
  schemarepr : CodeSnippet or object, optional
      An object whose repr will be used in the place of the explicit schema.
      This can be useful, for example, when the generated code should reference
      a predefined schema object. The user must ensure that the schema within
      the evaluated code is identical to the schema used to generate the code.
  rootschemarepr : CodeSnippet or object, optional
      An object whose repr will be used in the place of the explicit root
      schema.
  altair_classes_prefix : string, optional
  **kwargs : dict
      Additional keywords for derived classes.
code: def docstring(self, indent: int = 0) -> str:
      info = self.info
      doc = [
          "{} schema wrapper".format(self.classname),
      ]
      if info.description:
          doc += (
              self._process_description(  # remove condition description
                  re.sub(r"\n\{\n(\n|.)*\n\}", "", info.description)
              ).splitlines()
          )
      # Remove lines which contain the "raw-html" directive which cannot be processed
      # by Sphinx at this level of the docstring. It works for descriptions
      # of attributes which is why we do not do the same below. The removed
      # lines are anyway non-descriptive for a user.
      doc = [line for line in doc if ":raw-html:" not in line]
  
      if info.properties:
          arg_info = self.arg_info
          doc += ["", "Parameters", "----------", ""]
          for prop in (
              sorted(arg_info.required)
              + sorted(arg_info.kwds)
              + sorted(arg_info.invalid_kwds)
          ):
              propinfo = info.properties[prop]
              doc += [
                  "{} : {}".format(
                      prop,
                      propinfo.get_python_type_representation(
                          altair_classes_prefix=self.altair_classes_prefix,
                      ),
                  ),
                  "    {}".format(
                      self._process_description(
                          propinfo.deep_description
                      )
                  ),
              ]
      if len(doc) > 1:
          doc += [""]
      return indent_docstring(
          doc, indent_level=indent, width=100, lstrip=True
      )
  
imports: import re
  import textwrap
  from typing import Set, Final, Optional, List, Union, Dict, Tuple
  from dataclasses import dataclass
  from .utils import SchemaInfo, is_valid_identifier, indent_docstring, jsonschema_to_python_types, flatten
label_desc: Use image node_id 7 for calling the SchemaGenerator obj's underlying member method code with example usage: obj.docstring(indent) and returns: indent_docstring