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 get_args(self, si: SchemaInfo) -> List[str]:
      contents = ["self"]
      prop_infos: Dict[str, SchemaInfo] = {}
      if si.is_anyOf():
          prop_infos = {}
          for si_sub in si.anyOf:
              prop_infos.update(si_sub.properties)
      elif si.properties:
          prop_infos = dict(si.properties.items())
  
      if prop_infos:
          contents.extend(
              [
                  f"{p}: "
                  + info.get_python_type_representation(
                      for_type_hints=True,
                      altair_classes_prefix=self.altair_classes_prefix,
                      additional_type_hints=["UndefinedType"],
                  )
                  + " = Undefined"
                  for p, info in prop_infos.items()
              ]
          )
      elif si.type:
          py_type = jsonschema_to_python_types[si.type]
          if py_type == "list":
              # Try to get a type hint like "List[str]" which is more specific
              # then just "list"
              item_vl_type = si.items.get("type", None)
              if item_vl_type is not None:
                  item_type = jsonschema_to_python_types[item_vl_type]
              else:
                  item_si = SchemaInfo(si.items, self.rootschema)
                  assert item_si.is_reference()
                  altair_class_name = item_si.title
                  item_type = f"core.{altair_class_name}"
              py_type = f"List[{item_type}]"
          elif si.is_enum():
              # If it's an enum, we can type hint it as a Literal which tells
              # a type checker that only the values in enum are acceptable
              enum_values = [f'"{v}"' for v in si.enum]
              py_type = f"Literal[{', '.join(enum_values)}]"
          contents.append(f"_: {py_type}")
  
      contents.append("**kwds")
  
      return contents
  
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 10 for calling the SchemaGenerator obj's underlying member method code with example usage: obj.get_args(si) and returns: contents