text: """
  shapefile.py
  Provides read and write support for ESRI Shapefiles.
  author: jlawhead<at>geospatialpython.com
  date: 20110927
  version: 1.1.4
  Compatible with Python versions 2.4-3.x
  """
  
  from struct import pack, unpack, calcsize, error
  import os
  import sys
  import time
  import array
  #
  # Constants for shape types
  NULL = 0
  POINT = 1
  POLYLINE = 3
  POLYGON = 5
  MULTIPOINT = 8
  POINTZ = 11
  POLYLINEZ = 13
  POLYGONZ = 15
  MULTIPOINTZ = 18
  POINTM = 21
  POLYLINEM = 23
  POLYGONM = 25
  MULTIPOINTM = 28
  MULTIPATCH = 31
  
  PYTHON3 = sys.version_info[0] == 3
  
  def b(v):
      if PYTHON3:
          if isinstance(v, str):
              # For python 3 encode str to bytes.
              return v.encode('utf-8')
          elif isinstance(v, bytes):
              # Already bytes.
              return v
          else:
              # Error.
              raise Exception('Unknown input type')
      else:
          # For python 2 assume str passed in and return str.
          return v
  
  def u(v):
      if PYTHON3:
          if isinstance(v, bytes):
              # For python 3 decode bytes to str.
              return v.decode('utf-8')
          elif isinstance(v, str):
              # Already str.
              return v
          else:
              # Error.
              raise Exception('Unknown input type')
      else:
          # For python 2 assume str passed in and return str.
          return v
  
  def is_string(v):
      if PYTHON3:
          return isinstance(v, str)
      else:
          return isinstance(v, basestring)
  
  class _Array(array.array):
      """Converts python tuples to lits of the appropritate type.
      Used to unpack different shapefile header parts."""
      def __repr__(self):
          return str(self.tolist())
  
  class _Shape:
      def __init__(self, shapeType=None):
          """Stores the geometry of the different shape types
          specified in the Shapefile spec. Shape types are
          usually point, polyline, or polygons. Every shape type
          except the "Null" type contains points at some level for
          example verticies in a polygon. If a shape type has
          multiple shapes containing points within a single
          geometry record then those shapes are called parts. Parts
          are designated by their starting index in geometry record's
          list of shapes."""
          self.shapeType = shapeType
          self.points = []
  
  class _ShapeRecord:
      """A shape object of any type."""
      def __init__(self, shape=None, record=None):
          self.shape = shape
          self.record = record
  
  class ShapefileException(Exception):
      """An exception to handle shapefile specific problems."""
      pass
  
  class Reader:
      """Reads the three files of a shapefile as a unit or
      separately.  If one of the three files (.shp, .shx,
      .dbf) is missing no exception is thrown until you try
      to call a method that depends on that particular file.
      The .shx index file is used if available for efficiency
      but is not required to read the geometry from the .shp
      file. The "shapefile" argument in the constructor is the
      name of the file you want to open.
  
      You can instantiate a Reader without specifying a shapefile
      and then specify one later with the load() method.
  
      Only the shapefile headers are read upon loading. Content
      within each file is only accessed when required and as
      efficiently as possible. Shapefiles are usually not large
      but they can be.
      """
      def __init__(self, *args, **kwargs):
          self.shp = None
          self.shx = None
          self.dbf = None
          self.shapeName = "Not specified"
          self._offsets = []
          self.shpLength = None
          self.numRecords = None
          self.fields = []
          self.__dbfHdrLength = 0
          # See if a shapefile name was passed as an argument
          if len(args) > 0:
              if type(args[0]) is type("stringTest"):
                  self.load(args[0])
                  return
          if "shp" in kwargs.keys():
              if hasattr(kwargs["shp"], "read"):
                  self.shp = kwargs["shp"]
                  if hasattr(self.shp, "seek"):
                      self.shp.seek(0)
              if "shx" in kwargs.keys():
                  if hasattr(kwargs["shx"], "read"):
                      self.shx = kwargs["shx"]
                      if hasattr(self.shx, "seek"):
                          self.shx.seek(0)
          if "dbf" in kwargs.keys():
              if hasattr(kwargs["dbf"], "read"):
                  self.dbf = kwargs["dbf"]
                  if hasattr(self.dbf, "seek"):
                      self.dbf.seek(0)
          if self.shp or self.dbf:        
              self.load()
          else:
              raise ShapefileException("Shapefile Reader requires a shapefile or file-like object.")
  
      def load(self, shapefile=None):
          """Opens a shapefile from a filename or file-like
          object. Normally this method would be called by the
          constructor with the file object or file name as an
          argument."""
          if shapefile:
              (shapeName, ext) = os.path.splitext(shapefile)
              self.shapeName = shapeName
              try:
                  self.shp = open("%s.shp" % shapeName, "rb")
              except IOError:
                  raise ShapefileException("Unable to open %s.shp" % shapeName)
              try:
                  self.shx = open("%s.shx" % shapeName, "rb")
              except IOError:
                  raise ShapefileException("Unable to open %s.shx" % shapeName)
              try:
                  self.dbf = open("%s.dbf" % shapeName, "rb")
              except IOError:
                  raise ShapefileException("Unable to open %s.dbf" % shapeName)
          if self.shp:
              self.__shpHeader()
          if self.dbf:
              self.__dbfHeader()
  
      def __getFileObj(self, f):
          """Checks to see if the requested shapefile file object is
          available. If not a ShapefileException is raised."""
          if not f:
              raise ShapefileException("Shapefile Reader requires a shapefile or file-like object.")
          if self.shp and self.shpLength is None:
              self.load()
          if self.dbf and len(self.fields) == 0:
              self.load()
          return f
  
      def __restrictIndex(self, i):
          """Provides list-like handling of a record index with a clearer
          error message if the index is out of bounds."""
          if self.numRecords:
              rmax = self.numRecords - 1
              if abs(i) > rmax:
                  raise IndexError("Shape or Record index out of range.")
              if i < 0: i = range(self.numRecords)[i]
          return i
  
      def __shpHeader(self):
          """Reads the header information from a .shp or .shx file."""
          if not self.shp:
              raise ShapefileException("Shapefile Reader requires a shapefile or file-like object. (no shp file found")
          shp = self.shp
          # File length (16-bit word * 2 = bytes)
          shp.seek(24)
          self.shpLength = unpack(">i", shp.read(4))[0] * 2
          # Shape type
          shp.seek(32)
          self.shapeType= unpack("<i", shp.read(4))[0]
          # The shapefile's bounding box (lower left, upper right)
          self.bbox = _Array('d', unpack("<4d", shp.read(32)))
          # Elevation
          self.elevation = _Array('d', unpack("<2d", shp.read(16)))
          # Measure
          self.measure = _Array('d', unpack("<2d", shp.read(16)))
  
      def __shape(self):
          """Returns the header info and geometry for a single shape."""
          f = self.__getFileObj(self.shp)
          record = _Shape()
          nParts = nPoints = zmin = zmax = mmin = mmax = None
          (recNum, recLength) = unpack(">2i", f.read(8))
          shapeType = unpack("<i", f.read(4))[0]
          record.shapeType = shapeType
          # For Null shapes create an empty points list for consistency
          if shapeType == 0:
              record.points = []
          # All shape types capable of having a bounding box
          elif shapeType in (3,5,8,13,15,18,23,25,28,31):
              record.bbox = _Array('d', unpack("<4d", f.read(32)))
          # Shape types with parts
          if shapeType in (3,5,13,15,23,25,31):
              nParts = unpack("<i", f.read(4))[0]
          # Shape types with points
          if shapeType in (3,5,8,13,15,23,25,31):
              nPoints = unpack("<i", f.read(4))[0]
          # Read parts
          if nParts:
              record.parts = _Array('i', unpack("<%si" % nParts, f.read(nParts * 4)))
          # Read part types for Multipatch - 31
          if shapeType == 31:
              record.partTypes = _Array('i', unpack("<%si" % nParts, f.read(nParts * 4)))
          # Read points - produces a list of [x,y] values
          if nPoints:
              record.points = [_Array('d', unpack("<2d", f.read(16))) for p in range(nPoints)]
          # Read z extremes and values
          if shapeType in (13,15,18,31):
              (zmin, zmax) = unpack("<2d", f.read(16))
              record.z = _Array('d', unpack("<%sd" % nPoints, f.read(nPoints * 8)))
          # Read m extremes and values
          if shapeType in (13,15,18,23,25,28,31):
              (mmin, mmax) = unpack("<2d", f.read(16))
              # Measure values less than -10e38 are nodata values according to the spec
              record.m = []
              for m in _Array('d', unpack("%sd" % nPoints, f.read(nPoints * 8))):
                  if m > -10e38:
                      record.m.append(m)
                  else:
                      record.m.append(None)
          # Read a single point
          if shapeType in (1,11,21):
              record.points = [_Array('d', unpack("<2d", f.read(16)))]
          # Read a single Z value
          if shapeType == 11:
              record.z = unpack("<d", f.read(8))
          # Read a single M value
          if shapeType in (11,21):
              record.m = unpack("<d", f.read(8))
          return record
  
      def __shapeIndex(self, i=None):
          """Returns the offset in a .shp file for a shape based on information
          in the .shx index file."""
          shx = self.shx
          if not shx:
              return None
          if not self._offsets:
              # File length (16-bit word * 2 = bytes) - header length
              shx.seek(24)
              shxRecordLength = (unpack(">i", shx.read(4))[0] * 2) - 100
              numRecords = shxRecordLength // 8
              # Jump to the first record.
              shx.seek(100)
              for r in range(numRecords):
                  # Offsets are 16-bit words just like the file length
                  self._offsets.append(unpack(">i", shx.read(4))[0] * 2)
                  shx.seek(shx.tell() + 4)
          if not i == None:
              return self._offsets[i]
  
      def shape(self, i=0):
          """Returns a shape object for a shape in the the geometry
          record file."""
          shp = self.__getFileObj(self.shp)
          i = self.__restrictIndex(i)
          offset = self.__shapeIndex(i)
          if not offset:
              # Shx index not available so use the full list.
              shapes = self.shapes()
              return shapes[i]
          shp.seek(offset)
          return self.__shape()
  
      def shapes(self):
          """Returns all shapes in a shapefile."""
          shp = self.__getFileObj(self.shp)
          shp.seek(100)
          shapes = []
          while shp.tell() < self.shpLength:
              shapes.append(self.__shape())
          return shapes
  
      def __dbfHeaderLength(self):
          """Retrieves the header length of a dbf file header."""
          if not self.__dbfHdrLength:
              if not self.dbf:
                  raise ShapefileException("Shapefile Reader requires a shapefile or file-like object. (no dbf file found)")
              dbf = self.dbf
              (self.numRecords, self.__dbfHdrLength) = \
                      unpack("<xxxxLH22x", dbf.read(32))
          return self.__dbfHdrLength
  
      def __dbfHeader(self):
          """Reads a dbf header. Xbase-related code borrows heavily from ActiveState Python Cookbook Recipe 362715 by Raymond Hettinger"""
          if not self.dbf:
              raise ShapefileException("Shapefile Reader requires a shapefile or file-like object. (no dbf file found)")
          dbf = self.dbf
          headerLength = self.__dbfHeaderLength()
          numFields = (headerLength - 33) // 32
          for field in range(numFields):
              fieldDesc = list(unpack("<11sc4xBB14x", dbf.read(32)))
              name = 0
              idx = 0
              if b("\x00") in fieldDesc[name]:
                  idx = fieldDesc[name].index(b("\x00"))
              else:
                  idx = len(fieldDesc[name]) - 1
              fieldDesc[name] = fieldDesc[name][:idx]
              fieldDesc[name] = u(fieldDesc[name])
              fieldDesc[name] = fieldDesc[name].lstrip()
              fieldDesc[1] = u(fieldDesc[1])
              self.fields.append(fieldDesc)
          terminator = dbf.read(1)
          assert terminator == b("\r")
          self.fields.insert(0, ('DeletionFlag', 'C', 1, 0))
  
      def __recordFmt(self):
          """Calculates the size of a .shp geometry record."""
          if not self.numRecords:
              self.__dbfHeader()
          fmt = ''.join(['%ds' % fieldinfo[2] for fieldinfo in self.fields])
          fmtSize = calcsize(fmt)
          return (fmt, fmtSize)
  
      def __record(self):
          """Reads and returns a dbf record row as a list of values."""
          f = self.__getFileObj(self.dbf)
          recFmt = self.__recordFmt()
          recordContents = unpack(recFmt[0], f.read(recFmt[1]))
          if recordContents[0] != b(' '):
              # deleted record
              return None
          record = []
          for (name, typ, size, deci), value in zip(self.fields,recordContents):
    
              if name == 'DeletionFlag':
                  continue
              elif not value.strip():
                  record.append(value)
                  continue
              elif typ == "N":
                  try:
                      value = value.replace(b('\0'), b('')).strip()
                      if value == b(''):
                          value = 0
                      elif deci:
                          value = float(value)
                      else:
                          value = int(value)
                  except:
                      value = 0
              elif typ == b('D'):
                  try:
                      y, m, d = int(value[:4]), int(value[4:6]), int(value[6:8])
                      value = [y, m, d]
                  except:
                      value = value.strip()
              elif typ == b('L'):
                  value = (value in b('YyTt') and b('T')) or \
                                          (value in b('NnFf') and b('F')) or b('?')
              else:
                  value = u(value)
                  value = value.strip()
              record.append(value)
          return record
  
      def record(self, i=0):
          """Returns a specific dbf record based on the supplied index."""
          f = self.__getFileObj(self.dbf)
          if not self.numRecords:
              self.__dbfHeader()
          i = self.__restrictIndex(i)
          recSize = self.__recordFmt()[1]
          f.seek(0)
          f.seek(self.__dbfHeaderLength() + (i * recSize))
          return self.__record()
  
      def records(self):
          """Returns all records in a dbf file."""
          if not self.numRecords:
              self.__dbfHeader()
          records = []
          f = self.__getFileObj(self.dbf)
          f.seek(self.__dbfHeaderLength())
          for i in range(self.numRecords):
              r = self.__record()
              if r:
                  records.append(r)
          return records
  
      def shapeRecord(self, i=0):
          """Returns a combination geometry and attribute record for the
          supplied record index."""
          i = self.__restrictIndex(i)
          return _ShapeRecord(shape=self.shape(i),
                                                          record=self.record(i))
  
      def shapeRecords(self):
          """Returns a list of combination geometry/attribute records for
          all records in a shapefile."""
          shapeRecords = []
          return [_ShapeRecord(shape=rec[0], record=rec[1]) \
                                  for rec in zip(self.shapes(), self.records())]
  
  class Writer:
      """Provides write support for ESRI Shapefiles."""
      def __init__(self, shapeType=None):
          self._shapes = []
          self.fields = []
          self.records = []
          self.shapeType = shapeType
          self.shp = None
          self.shx = None
          self.dbf = None
          # Geometry record offsets and lengths for writing shx file.
          self._offsets = []
          self._lengths = []
          # Use deletion flags in dbf? Default is false (0).
          self.deletionFlag = 0
  
      def __getFileObj(self, f):
          """Safety handler to verify file-like objects"""
          if not f:
              raise ShapefileException("No file-like object available.")
          elif hasattr(f, "write"):
              return f
          else:
              pth = os.path.split(f)[0]
              if pth and not os.path.exists(pth):
                  os.makedirs(pth)
              return open(f, "wb")
  
      def __shpFileLength(self):
          """Calculates the file length of the shp file."""
          # Start with header length
          size = 100
          # Calculate size of all shapes
          for s in self._shapes:
              # Add in record header and shape type fields
              size += 12
              # nParts and nPoints do not apply to all shapes
              #if self.shapeType not in (0,1):
              #       nParts = len(s.parts)
              #       nPoints = len(s.points)
              if hasattr(s,'parts'):
                  nParts = len(s.parts)
              if hasattr(s,'points'):
                  nPoints = len(s.points)
              # All shape types capable of having a bounding box
              if self.shapeType in (3,5,8,13,15,18,23,25,28,31):
                  size += 32
              # Shape types with parts
              if self.shapeType in (3,5,13,15,23,25,31):
                  # Parts count
                  size += 4
                  # Parts index array
                  size += nParts * 4
              # Shape types with points
              if self.shapeType in (3,5,8,13,15,23,25,31):
                  # Points count
                  size += 4
                  # Points array
                  size += 16 * nPoints
              # Calc size of part types for Multipatch (31)
              if self.shapeType == 31:
                  size += nParts * 4
              # Calc z extremes and values
              if self.shapeType in (13,15,18,31):
                  # z extremes
                  size += 16
                  # z array
                  size += 8 * nPoints
              # Calc m extremes and values
              if self.shapeType in (23,25,31):
                  # m extremes
                  size += 16
                  # m array
                  size += 8 * nPoints
              # Calc a single point
              if self.shapeType in (1,11,21):
                  size += 16
              # Calc a single Z value
              if self.shapeType == 11:
                  size += 8
              # Calc a single M value
              if self.shapeType in (11,21):
                  size += 8
          # Calculate size as 16-bit words
          size //= 2
          return size
  
      def __bbox(self, shapes, shapeTypes=[]):
          x = []
          y = []
          for s in shapes:
              shapeType = self.shapeType
              if shapeTypes:
                  shapeType = shapeTypes[shapes.index(s)]
              px, py = list(zip(*s.points))[:2]
              x.extend(px)
              y.extend(py)
          return [min(x), min(y), max(x), max(y)]
  
      def __zbox(self, shapes, shapeTypes=[]):
          z = []
          for s in shapes:
              try:
                  for p in s.points:
                      z.append(p[2])
              except IndexError:
                  pass
          if not z: z.append(0)
          return [min(z), max(z)]
  
      def __mbox(self, shapes, shapeTypes=[]):
          m = [0]
          for s in shapes:
              try:
                  for p in s.points:
                      m.append(p[3])
              except IndexError:
                  pass
          return [min(m), max(m)]
  
      def bbox(self):
          """Returns the current bounding box for the shapefile which is
          the lower-left and upper-right corners. It does not contain the
          elevation or measure extremes."""
          return self.__bbox(self._shapes)
  
      def zbox(self):
          """Returns the current z extremes for the shapefile."""
          return self.__zbox(self._shapes)
  
      def mbox(self):
          """Returns the current m extremes for the shapefile."""
          return self.__mbox(self._shapes)
  
      def __shapefileHeader(self, fileObj, headerType='shp'):
          """Writes the specified header type to the specified file-like object.
          Several of the shapefile formats are so similar that a single generic
          method to read or write them is warranted."""
          f = self.__getFileObj(fileObj)
          f.seek(0)
          # File code, Unused bytes
          f.write(pack(">6i", 9994,0,0,0,0,0))
          # File length (Bytes / 2 = 16-bit words)
          if headerType == 'shp':
              f.write(pack(">i", self.__shpFileLength()))
          elif headerType == 'shx':
              f.write(pack('>i', ((100 + (len(self._shapes) * 8)) // 2)))
          # Version, Shape type
          f.write(pack("<2i", 1000, self.shapeType))
          # The shapefile's bounding box (lower left, upper right)
          if self.shapeType != 0:
              try:
                  f.write(pack("<4d", *self.bbox()))
              except error:
                  raise ShapefileException("Failed to write shapefile bounding box. Floats required.")
          else:
              f.write(pack("<4d", 0,0,0,0))
          # Elevation
          z = self.zbox()
          # Measure
          m = self.mbox()
          try:
              f.write(pack("<4d", z[0], z[1], m[0], m[1]))
          except error:
              raise ShapefileException("Failed to write shapefile elevation and measure values. Floats required.")
  
      def __dbfHeader(self):
          """Writes the dbf header and field descriptors."""
          f = self.__getFileObj(self.dbf)
          f.seek(0)
          version = 3
          year, month, day = time.localtime()[:3]
          year -= 1900
          # Remove deletion flag placeholder from fields
          for field in self.fields:
              if field[0].startswith("Deletion"):
                  self.fields.remove(field)
          numRecs = len(self.records)
          numFields = len(self.fields)
          headerLength = numFields * 32 + 33
          recordLength = sum([int(field[2]) for field in self.fields]) + 1
          header = pack('<BBBBLHH20x', version, year, month, day, numRecs,
                  headerLength, recordLength)
          f.write(header)
          # Field descriptors
          for field in self.fields:
              name, fieldType, size, decimal = field
              name = b(name)
              name = name.replace(b(' '), b('_'))
              name = name.ljust(11).replace(b(' '), b('\x00'))
              fieldType = b(fieldType)
              size = int(size)
              fld = pack('<11sc4xBB14x', name, fieldType, size, decimal)
              f.write(fld)
          # Terminator
          f.write(b('\r'))
  
      def __shpRecords(self):
          """Write the shp records"""
          f = self.__getFileObj(self.shp)
          f.seek(100)
          recNum = 1
          for s in self._shapes:
              self._offsets.append(f.tell())
              # Record number, Content length place holder
              f.write(pack(">2i", recNum, 0))
              recNum += 1
              start = f.tell()
              # Shape Type
              f.write(pack("<i", s.shapeType))
              # All shape types capable of having a bounding box
              if s.shapeType in (3,5,8,13,15,18,23,25,28,31):
                  try:
                      f.write(pack("<4d", *self.__bbox([s])))
                  except error:
                      raise ShapefileException("Falied to write bounding box for record %s. Expected floats." % recNum)
              # Shape types with parts
              if s.shapeType in (3,5,13,15,23,25,31):
                  # Number of parts
                  f.write(pack("<i", len(s.parts)))
              # Shape types with multiple points per record
              if s.shapeType in (3,5,8,13,15,23,25,31):
                  # Number of points
                  f.write(pack("<i", len(s.points)))
              # Write part indexes
              if s.shapeType in (3,5,13,15,23,25,31):
                  for p in s.parts:
                      f.write(pack("<i", p))
              # Part types for Multipatch (31)
              if s.shapeType == 31:
                  for pt in s.partTypes:
                      f.write(pack("<i", pt))
              # Write points for multiple-point records
              if s.shapeType in (3,5,8,13,15,23,25,31):
                  try:
                      [f.write(pack("<2d", *p[:2])) for p in s.points]
                  except error:
                      raise ShapefileException("Failed to write points for record %s. Expected floats." % recNum)
              # Write z extremes and values
              if s.shapeType in (13,15,18,31):
                  try:
                      f.write(pack("<2d", *self.__zbox([s])))
                  except error:
                      raise ShapefileException("Failed to write elevation extremes for record %s. Expected floats." % recNum)
                  try:
                      [f.write(pack("<d", p[2])) for p in s.points]
                  except error:
                      raise ShapefileException("Failed to write elevation values for record %s. Expected floats." % recNum)
              # Write m extremes and values
              if s.shapeType in (23,25,31):
                  try:
                      f.write(pack("<2d", *self.__mbox([s])))
                  except error:
                      raise ShapefileException("Failed to write measure extremes for record %s. Expected floats" % recNum)
                  try:
                      [f.write(pack("<d", p[3])) for p in s.points]
                  except error:
                      raise ShapefileException("Failed to write measure values for record %s. Expected floats" % recNum)
              # Write a single point
              if s.shapeType in (1,11,21):
                  try:
                      f.write(pack("<2d", s.points[0][0], s.points[0][1]))
                  except error:
                      raise ShapefileException("Failed to write point for record %s. Expected floats." % recNum)
              # Write a single Z value
              if s.shapeType == 11:
                  try:
                      f.write(pack("<1d", s.points[0][2]))
                  except error:
                      raise ShapefileException("Failed to write elevation value for record %s. Expected floats." % recNum)
              # Write a single M value
              if s.shapeType in (11,21):
                  try:
                      f.write(pack("<1d", s.points[0][3]))
                  except error:
                      raise ShapefileException("Failed to write measure value for record %s. Expected floats." % recNum)
              # Finalize record length as 16-bit words
              finish = f.tell()
              length = (finish - start) // 2
              self._lengths.append(length)
              # start - 4 bytes is the content length field
              f.seek(start-4)
              f.write(pack(">i", length))
              f.seek(finish)
  
      def __shxRecords(self):
          """Writes the shx records."""
          f = self.__getFileObj(self.shx)
          f.seek(100)
          for i in range(len(self._shapes)):
              f.write(pack(">i", self._offsets[i] // 2))
              f.write(pack(">i", self._lengths[i]))
  
      def __dbfRecords(self):
          """Writes the dbf records."""
          f = self.__getFileObj(self.dbf)
          for record in self.records:
              if not self.fields[0][0].startswith("Deletion"):
                  f.write(b(' ')) # deletion flag
              for (fieldName, fieldType, size, dec), value in zip(self.fields, record):
                  fieldType = fieldType.upper()
                  size = int(size)
                  if fieldType.upper() == "N":
                      value = str(value).rjust(size)
                  elif fieldType == 'L':
                      value = str(value)[0].upper()
                  else:
                      value = str(value)[:size].ljust(size)
                  assert len(value) == size
                  value = b(value)
                  f.write(value)
  
      def null(self):
          """Creates a null shape."""
          self._shapes.append(_Shape(NULL))
  
      def point(self, x, y, z=0, m=0):
          """Creates a point shape."""
          pointShape = _Shape(self.shapeType)
          pointShape.points.append([x, y, z, m])
          self._shapes.append(pointShape)
  
      def line(self, parts=[], shapeType=POLYLINE):
          """Creates a line shape. This method is just a convienience method
          which wraps 'poly()'.
          """
          self.poly(parts, shapeType, [])
  
      def poly(self, parts=[], shapeType=POLYGON, partTypes=[]):
          """Creates a shape that has multiple collections of points (parts)
          including lines, polygons, and even multipoint shapes. If no shape type
          is specified it defaults to 'polygon'. If no part types are specified
          (which they normally won't be) then all parts default to the shape type.
          """
          polyShape = _Shape(shapeType)
          polyShape.parts = []
          polyShape.points = []
          for part in parts:
              polyShape.parts.append(len(polyShape.points))
              for point in part:
                  # Ensure point is list
                  if not isinstance(point, list):
                      point = list(point)
                  # Make sure point has z and m values
                  while len(point) < 4:
                      point.append(0)
                  polyShape.points.append(point)
          if polyShape.shapeType == 31:
              if not partTypes:
                  for part in parts:
                      partTypes.append(polyShape.shapeType)
              polyShape.partTypes = partTypes
          self._shapes.append(polyShape)
  
      def field(self, name, fieldType="C", size="50", decimal=0):
          """Adds a dbf field descriptor to the shapefile."""
          self.fields.append((name, fieldType, size, decimal))
  
      def record(self, *recordList, **recordDict):
          """Creates a dbf attribute record. You can submit either a sequence of
          field values or keyword arguments of field names and values. Before
          adding records you must add fields for the record values using the
          fields() method. If the record values exceed the number of fields the
          extra ones won't be added. In the case of using keyword arguments to specify
          field/value pairs only fields matching the already registered fields
          will be added."""
          record = []
          fieldCount = len(self.fields)
          # Compensate for deletion flag
          if self.fields[0][0].startswith("Deletion"): fieldCount -= 1
          if recordList:
              [record.append(recordList[i]) for i in range(fieldCount)]
          elif recordDict:
              for field in self.fields:
                  if field[0] in recordDict:
                      val = recordDict[field[0]]
                      if val:
                          record.append(val)
                      else:
                          record.append("")
          if record:
              self.records.append(record)
  
      def shape(self, i):
          return self._shapes[i]
  
      def shapes(self):
          """Return the current list of shapes."""
          return self._shapes
  
      def saveShp(self, target):
          """Save an shp file."""
          if not hasattr(target, "write"):
              target = os.path.splitext(target)[0] + '.shp'
          if not self.shapeType:
              self.shapeType = self._shapes[0].shapeType
          self.shp = self.__getFileObj(target)
          self.__shapefileHeader(self.shp, headerType='shp')
          self.__shpRecords()
  
      def saveShx(self, target):
          """Save an shx file."""
          if not hasattr(target, "write"):
              target = os.path.splitext(target)[0] + '.shx'
          if not self.shapeType:
              self.shapeType = self._shapes[0].shapeType
          self.shx = self.__getFileObj(target)
          self.__shapefileHeader(self.shx, headerType='shx')
          self.__shxRecords()
  
      def saveDbf(self, target):
          """Save a dbf file."""
          if not hasattr(target, "write"):
              target = os.path.splitext(target)[0] + '.dbf'
          self.dbf = self.__getFileObj(target)
          self.__dbfHeader()
          self.__dbfRecords()
  
      def save(self, target=None, shp=None, shx=None, dbf=None):
          """Save the shapefile data to three files or
          three file-like objects. SHP and DBF files can also
          be written exclusively using saveShp, saveShx, and saveDbf respectively."""
          # TODO: Create a unique filename for target if None.
          if shp:
              self.saveShp(shp)
          if shx:
              self.saveShx(shx)
          if dbf:
              self.saveDbf(dbf)
          elif target:
              self.saveShp(target)
              self.shp.close()
              self.saveShx(target)
              self.shx.close()
              self.saveDbf(target)
              self.dbf.close()
  
  class Editor(Writer):
      def __init__(self, shapefile=None, shapeType=POINT, autoBalance=1):
          self.autoBalance = autoBalance
          if not shapefile:
              Writer.__init__(self, shapeType)
          elif is_string(shapefile):
              base = os.path.splitext(shapefile)[0]
              if os.path.isfile("%s.shp" % base):
                  r = Reader(base)
                  Writer.__init__(self, r.shapeType)
                  self._shapes = r.shapes()
                  self.fields = r.fields
                  self.records = r.records()
  
      def select(self, expr):
          """Select one or more shapes (to be implemented)"""
          # TODO: Implement expressions to select shapes.
          pass
  
      def delete(self, shape=None, part=None, point=None):
          """Deletes the specified part of any shape by specifying a shape
          number, part number, or point number."""
          # shape, part, point
          if shape and part and point:
              del self._shapes[shape][part][point]
          # shape, part
          elif shape and part and not point:
              del self._shapes[shape][part]
          # shape
          elif shape and not part and not point:
              del self._shapes[shape]
          # point
          elif not shape and not part and point:
              for s in self._shapes:
                  if s.shapeType == 1:
                      del self._shapes[point]
                  else:
                      for part in s.parts:
                          del s[part][point]
          # part, point
          elif not shape and part and point:
              for s in self._shapes:
                  del s[part][point]
          # part
          elif not shape and part and not point:
              for s in self._shapes:
                  del s[part]
  
      def point(self, x=None, y=None, z=None, m=None, shape=None, part=None, point=None, addr=None):
          """Creates/updates a point shape. The arguments allows
          you to update a specific point by shape, part, point of any
          shape type."""
          # shape, part, point
          if shape and part and point:
              try: self._shapes[shape]
              except IndexError: self._shapes.append([])
              try: self._shapes[shape][part]
              except IndexError: self._shapes[shape].append([])
              try: self._shapes[shape][part][point]
              except IndexError: self._shapes[shape][part].append([])
              p = self._shapes[shape][part][point]
              if x: p[0] = x
              if y: p[1] = y
              if z: p[2] = z
              if m: p[3] = m
              self._shapes[shape][part][point] = p
          # shape, part
          elif shape and part and not point:
              try: self._shapes[shape]
              except IndexError: self._shapes.append([])
              try: self._shapes[shape][part]
              except IndexError: self._shapes[shape].append([])
              points = self._shapes[shape][part]
              for i in range(len(points)):
                  p = points[i]
                  if x: p[0] = x
                  if y: p[1] = y
                  if z: p[2] = z
                  if m: p[3] = m
                  self._shapes[shape][part][i] = p
          # shape
          elif shape and not part and not point:
              try: self._shapes[shape]
              except IndexError: self._shapes.append([])
  
          # point
          # part
          if addr:
              shape, part, point = addr
              self._shapes[shape][part][point] = [x, y, z, m]
          else:
              Writer.point(self, x, y, z, m)
          if self.autoBalance:
              self.balance()
  
      def validate(self):
          """An optional method to try and validate the shapefile
          as much as possible before writing it (not implemented)."""
          #TODO: Implement validation method
          pass
  
      def balance(self):
          """Adds a corresponding empty attribute or null geometry record depending
          on which type of record was created to make sure all three files
          are in synch."""
          if len(self.records) > len(self._shapes):
              self.null()
          elif len(self.records) < len(self._shapes):
              self.record()
  
      def __fieldNorm(self, fieldName):
          """Normalizes a dbf field name to fit within the spec and the
          expectations of certain ESRI software."""
          if len(fieldName) > 11: fieldName = fieldName[:11]
          fieldName = fieldName.upper()
          fieldName.replace(' ', '_')
  
  # Begin Testing
  def test():
      import doctest
      doctest.NORMALIZE_WHITESPACE = 1
      doctest.testfile("README.txt", verbose=1)
  
  if __name__ == "__main__":
      """
      Doctests are contained in the module 'pyshp_usage.py'. This library was developed
      using Python 2.3. Python 2.4 and above have some excellent improvements in the built-in
      testing libraries but for now unit testing is done using what's available in
      2.3.
      """
      test()
  