docs: def Parse(self, statentry, file_object, knowledge_base):
      """Parse the Plist file."""
      _ = knowledge_base
      kwargs = {}
      try:
        kwargs["aff4path"] = file_object.urn
      except AttributeError:
        pass
  
      direct_copy_items = [
          "Label", "Disabled", "UserName", "GroupName", "Program",
          "StandardInPath", "StandardOutPath", "StandardErrorPath",
          "LimitLoadToSessionType", "EnableGlobbing", "EnableTransactions",
          "OnDemand", "RunAtLoad", "RootDirectory", "WorkingDirectory", "Umask",
          "TimeOut", "ExitTimeOut", "ThrottleInterval", "InitGroups",
          "StartOnMount", "StartInterval", "Debug", "WaitForDebugger", "Nice",
          "ProcessType", "AbandonProcessGroup", "LowPriorityIO", "LaunchOnlyOnce"
      ]
  
      string_array_items = [
          "LimitLoadToHosts", "LimitLoadFromHosts", "LimitLoadToSessionType",
          "ProgramArguments", "WatchPaths", "QueueDirectories"
      ]
  
      flag_only_items = ["SoftResourceLimits", "HardResourceLimits", "Sockets"]
  
      plist = {}
  
      try:
        plist = biplist.readPlist(file_object)
      except (biplist.InvalidPlistException, ValueError, IOError) as e:
        plist["Label"] = "Could not parse plist: %s" % e
  
      # These are items that can be directly copied
      for key in direct_copy_items:
        kwargs[key] = plist.get(key)
  
      # These could be a string, they could be an array, we don't know and neither
      # does Apple so we check.
      for key in string_array_items:
        elements = plist.get(key)
        if isinstance(elements, string_types):
          kwargs[key] = [elements]
        else:
          kwargs[key] = elements
  
      # These are complex items that can appear in multiple data structures
      # so we only flag on their existence
      for key in flag_only_items:
        if plist.get(key):
          kwargs[key] = True
  
      if plist.get("inetdCompatability") is not None:
        kwargs["inetdCompatabilityWait"] = plist.get("inetdCompatability").get(
            "Wait")
  
      keepalive = plist.get("KeepAlive")
      if isinstance(keepalive, bool) or keepalive is None:
        kwargs["KeepAlive"] = keepalive
      else:
        keepalivedict = {}
        keepalivedict["SuccessfulExit"] = keepalive.get("SuccessfulExit")
        keepalivedict["NetworkState"] = keepalive.get("NetworkState")
  
        pathstates = keepalive.get("PathState")
        if pathstates is not None:
          keepalivedict["PathState"] = []
          for pathstate in pathstates:
            keepalivedict["PathState"].append(
                rdf_plist.PlistBoolDictEntry(
                    name=pathstate, value=pathstates[pathstate]))
  
        otherjobs = keepalive.get("OtherJobEnabled")
        if otherjobs is not None:
          keepalivedict["OtherJobEnabled"] = []
          for otherjob in otherjobs:
            keepalivedict["OtherJobEnabled"].append(
                rdf_plist.PlistBoolDictEntry(
                    name=otherjob, value=otherjobs[otherjob]))
        kwargs["KeepAliveDict"] = rdf_plist.LaunchdKeepAlive(**keepalivedict)
  
      envvars = plist.get("EnvironmentVariables")
      if envvars is not None:
        kwargs["EnvironmentVariables"] = []
        for envvar in envvars:
          kwargs["EnvironmentVariables"].append(
              rdf_plist.PlistStringDictEntry(name=envvar, value=envvars[envvar]))
  
      startcalendarinterval = plist.get("StartCalendarInterval")
      if startcalendarinterval is not None:
        if isinstance(startcalendarinterval, dict):
          kwargs["StartCalendarInterval"] = [
              rdf_plist.LaunchdStartCalendarIntervalEntry(
                  Minute=startcalendarinterval.get("Minute"),
                  Hour=startcalendarinterval.get("Hour"),
                  Day=startcalendarinterval.get("Day"),
                  Weekday=startcalendarinterval.get("Weekday"),
                  Month=startcalendarinterval.get("Month"))
          ]
        else:
          kwargs["StartCalendarInterval"] = []
          for entry in startcalendarinterval:
            kwargs["StartCalendarInterval"].append(
                rdf_plist.LaunchdStartCalendarIntervalEntry(
                    Minute=entry.get("Minute"),
                    Hour=entry.get("Hour"),
                    Day=entry.get("Day"),
                    Weekday=entry.get("Weekday"),
                    Month=entry.get("Month")))
  
      yield rdf_plist.LaunchdPlist(**kwargs)