docs: def addByPart(self, filePath):
          """
             Allows for large file uploads to be split into 50 MB chunks and
             to be sent to AGOL/Portal.  This resolves an issue in Python,
             where the multi-part POST runs out of memory.
             To use this function, an addItem() must be run first and that
             item id must be passed into this function.
  
             Once the file is uploaded, a commit() must be performed on the
             data to have all the parts merged together.
  
             No item properties will be inherited from the initial AddItem()
             call unless it is an sd file.  Therefore you must call
             updateItem() on the recently updated item.
  
             Example:
                fp = r"c:\temp\big.zip"
                #.... AGOL init stuff
                #....
                usercontent = agol.content.usercontent(username)
                res = usercontent.addItem(itemParameters=None,
                                    filePath=fp,
                                    overwrite=True,
                                    multipart=True)
                res = usercontent.addByPart(filePath=fp)
                res = usercontent.commit(itemId)
                usercontent.updateItem(updateItemParameters=ip)
                # Item added and updated.
             Inputs:
                filePath - location of the file on disk
                itemId - empty item added to AGOL/Portal
                folder - folder id
          """
          def read_in_chunks(file_object, chunk_size=10000000):
              """Generate file chunks of 10MB"""
              while True:
                  data = file_object.read(chunk_size)
                  if not data:
                      break
                  yield data
          params = {
          "f" : "json",
          'itemType' : 'file'
          }
          url = '%s/addPart' % self.root
          messages = []
          files = {}
          with open(filePath, 'rb') as f:
              for part_num, piece in enumerate(read_in_chunks(f), start=1):
                  params['partNum'] = part_num
                  tempFile = os.path.join(os.environ['TEMP'], "split.part%s" % part_num)
                  files['file'] =  [tempFile, os.path.basename(filePath)]
                  with open(tempFile, 'wb') as writer:
                      writer.write(piece)
                      del writer
                  res = self._post(url=url,
                                   param_dict=params,
                                   files=files,
                                   securityHandler=self._securityHandler,
                                   proxy_url=self._proxy_url,
                                   proxy_port=self._proxy_port)
                  if os.path.isfile(tempFile):
                      os.remove(tempFile)
                  del files
                  del tempFile
                  files = {}
                  messages.append(res)
          return messages