docs: def _readSingleInstanceElement(self, instanceElement, makeGlyphs=True, makeKerning=True, makeInfo=True):
          """ Read a single instance element.
              If we have glyph specifications, only make those.
              Otherwise make all available glyphs.
          """
          # get the data from the instanceElement itself
          filename = instanceElement.attrib.get('filename')
  
          instancePath = os.path.join(os.path.dirname(self.path), filename)
          self.reportProgress("generate", 'start', instancePath)
          if self.verbose and self.logger:
              self.logger.info("\tGenerating instance %s", os.path.basename(instancePath))
          filenameTokenForResults = os.path.basename(filename)
  
          instanceObject = self._instanceWriterClass(instancePath,
              ufoVersion=self.ufoVersion,
              roundGeometry=self.roundGeometry,
              axes = self.axes,
              verbose=self.verbose,
              logger=self.logger
              )
          self.results[filenameTokenForResults] = instancePath
  
          # set the masters
          instanceObject.setSources(self.sources)
          self.unicodeMap = instanceObject.makeUnicodeMapFromSources()
          instanceObject.setMuted(self.muted)
          familyname = instanceElement.attrib.get('familyname')
          if familyname is not None:
              instanceObject.setFamilyName(familyname)
          stylename = instanceElement.attrib.get('stylename')
          if stylename is not None:
              instanceObject.setStyleName(stylename)
          postScriptFontName = instanceElement.attrib.get('postscriptfontname')
          if postScriptFontName is not None:
              instanceObject.setPostScriptFontName(postScriptFontName)
          styleMapFamilyName = instanceElement.attrib.get('stylemapfamilyname')
          if styleMapFamilyName is not None:
              instanceObject.setStyleMapFamilyName(styleMapFamilyName)
          styleMapStyleName = instanceElement.attrib.get('stylemapstylename')
          if styleMapStyleName is not None:
              instanceObject.setStyleMapStyleName(styleMapStyleName)
  
          # location
          instanceLocation = self.locationFromElement(instanceElement)
  
          if instanceLocation is not None:
              instanceObject.setLocation(instanceLocation)
  
          if makeGlyphs:
  
              # step 1: generate all glyphs we have mutators for.
              names = instanceObject.getAvailableGlyphnames()
              for n in names:
                  unicodes = self.unicodeMap.get(n, None)
                  try:
                      instanceObject.addGlyph(n, unicodes)
                  except AssertionError:
                      if self.verbose and self.logger:
                          self.logger.info("Problem making glyph %s, skipping.", n)
              # step 2: generate all the glyphs that have special definitions.
              for glyphElement in instanceElement.findall('.glyphs/glyph'):
                  self.readGlyphElement(glyphElement, instanceObject)
  
          # read the kerning
          if makeKerning:
              for kerningElement in instanceElement.findall('.kerning'):
                  self.readKerningElement(kerningElement, instanceObject)
                  break
  
          # read the fontinfo
          if makeInfo:
              for infoElement in instanceElement.findall('.info'):
                  self.readInfoElement(infoElement, instanceObject)
  
          # copy the features
          if self.featuresSource is not None:
              instanceObject.copyFeatures(self.featuresSource)
  
          # copy the groups
          if self.groupsSource is not None:
              if self.groupsSource in self.sources:
                  groupSourceObject, loc = self.sources[self.groupsSource]
                  # copy the groups from the designated source to the new instance
                  # note: setGroups will filter the group members
                  # only glyphs present in the font will be added to the group.
                  # Depending on the ufoversion we might or might not expect the kerningGroupConversionRenameMaps attribute.
                  if hasattr(groupSourceObject, "kerningGroupConversionRenameMaps"):
                      renameMap = groupSourceObject.kerningGroupConversionRenameMaps
                  else:
                      renameMap = {}
                  instanceObject.setGroups(groupSourceObject.groups, kerningGroupConversionRenameMaps=renameMap)
  
          # lib items
          if self.libSource is not None:
              if self.libSource in self.sources:
                  libSourceObject, loc = self.sources[self.libSource]
                  instanceObject.setLib(libSourceObject.lib)
  
          # save the instance. Done.
          success, report = instanceObject.save()
          if not success and self.logger:
              # report problems other than validation errors and failed glyphs
              self.logger.info("%s:\nErrors generating: %s", filename, report)
  
          # report failed glyphs
          failed = instanceObject.getFailed()
          if failed:
              failed.sort()
              msg = "%s:\nErrors calculating %s glyphs: \n%s"%(filename, len(failed),"\t"+"\n\t".join(failed))
              self.reportProgress('error', 'glyphs', msg)
              if self.verbose and self.logger:
                  self.logger.info(msg)
  
          # report missing unicodes
          missing = instanceObject.getMissingUnicodes()
          if missing:
              missing.sort()
              msg = "%s:\nPossibly missing unicodes for %s glyphs: \n%s"%(filename, len(missing),"\t"+"\n\t".join(missing))
              self.reportProgress('error', 'unicodes', msg)
  
          # store
          self.instances[postScriptFontName] = instanceObject
          self.reportProgress("generate", 'stop', filenameTokenForResults)