text: from fontTools.misc.py23 import bytesjoin, tostr
  from io import BytesIO
  import struct
  from fontTools.misc import sstruct
  from collections import OrderedDict
  from collections.abc import MutableMapping
  
  
  class ResourceError(Exception):
  	pass
  
  
  class ResourceReader(MutableMapping):
  	"""Reader for Mac OS resource forks.
  
  	Parses a resource fork and returns resources according to their type.
  	If run on OS X, this will open the resource fork in the filesystem.
  	Otherwise, it will open the file itself and attempt to read it as
  	though it were a resource fork.
  
  	The returned object can be indexed by type and iterated over,
  	returning in each case a list of py:class:`Resource` objects
  	representing all the resources of a certain type.
  
  	"""
  	def __init__(self, fileOrPath):
  		"""Open a file
  
  		Args:
  			fileOrPath: Either an object supporting a ``read`` method, an
  				``os.PathLike`` object, or a string.
  		"""
  		self._resources = OrderedDict()
  		if hasattr(fileOrPath, 'read'):
  			self.file = fileOrPath
  		else:
  			try:
  				# try reading from the resource fork (only works on OS X)
  				self.file = self.openResourceFork(fileOrPath)
  				self._readFile()
  				return
  			except (ResourceError, IOError):
  				# if it fails, use the data fork
  				self.file = self.openDataFork(fileOrPath)
  		self._readFile()
  
  	@staticmethod
  	def openResourceFork(path):
  		if hasattr(path, "__fspath__"):  # support os.PathLike objects
  			path = path.__fspath__()
  		with open(path + '/..namedfork/rsrc', 'rb') as resfork:
  			data = resfork.read()
  		infile = BytesIO(data)
  		infile.name = path
  		return infile
  
  	@staticmethod
  	def openDataFork(path):
  		with open(path, 'rb') as datafork:
  			data = datafork.read()
  		infile = BytesIO(data)
  		infile.name = path
  		return infile
  
  	def _readFile(self):
  		self._readHeaderAndMap()
  		self._readTypeList()
  
  	def _read(self, numBytes, offset=None):
  		if offset is not None:
  			try:
  				self.file.seek(offset)
  			except OverflowError:
  				raise ResourceError("Failed to seek offset ('offset' is too large)")
  			if self.file.tell() != offset:
  				raise ResourceError('Failed to seek offset (reached EOF)')
  		try:
  			data = self.file.read(numBytes)
  		except OverflowError:
  			raise ResourceError("Cannot read resource ('numBytes' is too large)")
  		if len(data) != numBytes:
  			raise ResourceError('Cannot read resource (not enough data)')
  		return data
  
  	def _readHeaderAndMap(self):
  		self.file.seek(0)
  		headerData = self._read(ResourceForkHeaderSize)
  		sstruct.unpack(ResourceForkHeader, headerData, self)
  		# seek to resource map, skip reserved
  		mapOffset = self.mapOffset + 22
  		resourceMapData = self._read(ResourceMapHeaderSize, mapOffset)
  		sstruct.unpack(ResourceMapHeader, resourceMapData, self)
  		self.absTypeListOffset = self.mapOffset + self.typeListOffset
  		self.absNameListOffset = self.mapOffset + self.nameListOffset
  
  	def _readTypeList(self):
  		absTypeListOffset = self.absTypeListOffset
  		numTypesData = self._read(2, absTypeListOffset)
  		self.numTypes, = struct.unpack('>H', numTypesData)
  		absTypeListOffset2 = absTypeListOffset + 2
  		for i in range(self.numTypes + 1):
  			resTypeItemOffset = absTypeListOffset2 + ResourceTypeItemSize * i
  			resTypeItemData = self._read(ResourceTypeItemSize, resTypeItemOffset)
  			item = sstruct.unpack(ResourceTypeItem, resTypeItemData)
  			resType = tostr(item['type'], encoding='mac-roman')
  			refListOffset = absTypeListOffset + item['refListOffset']
  			numRes = item['numRes'] + 1
  			resources = self._readReferenceList(resType, refListOffset, numRes)
  			self._resources[resType] = resources
  
  	def _readReferenceList(self, resType, refListOffset, numRes):
  		resources = []
  		for i in range(numRes):
  			refOffset = refListOffset + ResourceRefItemSize * i
  			refData = self._read(ResourceRefItemSize, refOffset)
  			res = Resource(resType)
  			res.decompile(refData, self)
  			resources.append(res)
  		return resources
  
  	def __getitem__(self, resType):
  		return self._resources[resType]
  
  	def __delitem__(self, resType):
  		del self._resources[resType]
  
  	def __setitem__(self, resType, resources):
  		self._resources[resType] = resources
  
  	def __len__(self):
  		return len(self._resources)
  
  	def __iter__(self):
  		return iter(self._resources)
  
  	def keys(self):
  		return self._resources.keys()
  
  	@property
  	def types(self):
  		"""A list of the types of resources in the resource fork."""
  		return list(self._resources.keys())
  
  	def countResources(self, resType):
  		"""Return the number of resources of a given type."""
  		try:
  			return len(self[resType])
  		except KeyError:
  			return 0
  
  	def getIndices(self, resType):
  		"""Returns a list of indices of resources of a given type."""
  		numRes = self.countResources(resType)
  		if numRes:
  			return list(range(1, numRes+1))
  		else:
  			return []
  
  	def getNames(self, resType):
  		"""Return list of names of all resources of a given type."""
  		return [res.name for res in self.get(resType, []) if res.name is not None]
  
  	def getIndResource(self, resType, index):
  		"""Return resource of given type located at an index ranging from 1
  		to the number of resources for that type, or None if not found.
  		"""
  		if index < 1:
  			return None
  		try:
  			res = self[resType][index-1]
  		except (KeyError, IndexError):
  			return None
  		return res
  
  	def getNamedResource(self, resType, name):
  		"""Return the named resource of given type, else return None."""
  		name = tostr(name, encoding='mac-roman')
  		for res in self.get(resType, []):
  			if res.name == name:
  				return res
  		return None
  
  	def close(self):
  		if not self.file.closed:
  			self.file.close()
  
  
  class Resource(object):
  	"""Represents a resource stored within a resource fork.
  
  	Attributes:
  		type: resource type.
  		data: resource data.
  		id: ID.
  		name: resource name.
  		attr: attributes.
  	"""
  
  	def __init__(self, resType=None, resData=None, resID=None, resName=None,
  			     resAttr=None):
  		self.type = resType
  		self.data = resData
  		self.id = resID
  		self.name = resName
  		self.attr = resAttr
  
  	def decompile(self, refData, reader):
  		sstruct.unpack(ResourceRefItem, refData, self)
  		# interpret 3-byte dataOffset as (padded) ULONG to unpack it with struct
  		self.dataOffset, = struct.unpack('>L', bytesjoin([b"\0", self.dataOffset]))
  		absDataOffset = reader.dataOffset + self.dataOffset
  		dataLength, = struct.unpack(">L", reader._read(4, absDataOffset))
  		self.data = reader._read(dataLength)
  		if self.nameOffset == -1:
  			return
  		absNameOffset = reader.absNameListOffset + self.nameOffset
  		nameLength, = struct.unpack('B', reader._read(1, absNameOffset))
  		name, = struct.unpack('>%ss' % nameLength, reader._read(nameLength))
  		self.name = tostr(name, encoding='mac-roman')
  
  
  ResourceForkHeader = """
  		> # big endian
  		dataOffset:     L
  		mapOffset:      L
  		dataLen:        L
  		mapLen:         L
  """
  
  ResourceForkHeaderSize = sstruct.calcsize(ResourceForkHeader)
  
  ResourceMapHeader = """
  		> # big endian
  		attr:              H
  		typeListOffset:    H
  		nameListOffset:    H
  """
  
  ResourceMapHeaderSize = sstruct.calcsize(ResourceMapHeader)
  
  ResourceTypeItem = """
  		> # big endian
  		type:              4s
  		numRes:            H
  		refListOffset:     H
  """
  
  ResourceTypeItemSize = sstruct.calcsize(ResourceTypeItem)
  
  ResourceRefItem = """
  		> # big endian
  		id:                h
  		nameOffset:        h
  		attr:              B
  		dataOffset:        3s
  		reserved:          L
  """
  
  ResourceRefItemSize = sstruct.calcsize(ResourceRefItem)
  