docs: def _chunk_putter(self, uri, open_file, headers=None):
          """Make many PUT request for a single chunked object.
  
          Objects that are processed by this method have a SHA256 hash appended
          to the name as well as a count for object indexing which starts at 0.
  
          To make a PUT request pass, ``url``
  
          :param uri: ``str``
          :param open_file: ``object``
          :param headers: ``dict``
          """
          count = 0
          dynamic_hash = hashlib.sha256(self.job_args.get('container'))
          dynamic_hash = dynamic_hash.hexdigest()
          while True:
              # Read in a chunk of an open file
              file_object = open_file.read(self.job_args.get('chunk_size'))
              if not file_object:
                  break
  
              # When a chuck is present store it as BytesIO
              with io.BytesIO(file_object) as file_object:
                  # store the parsed URI for the chunk
                  chunk_uri = urlparse.urlparse(
                      '%s.%s.%s' % (
                          uri.geturl(),
                          dynamic_hash,
                          count
                      )
                  )
  
                  # Increment the count as soon as it is used
                  count += 1
  
                  # Check if the read chunk already exists
                  sync = self._sync_check(
                      uri=chunk_uri,
                      headers=headers,
                      file_object=file_object
                  )
                  if not sync:
                      continue
  
                  # PUT the chunk
                  _resp = self.http.put(
                      url=chunk_uri,
                      body=file_object,
                      headers=headers
                  )
                  self._resp_exception(resp=_resp)
                  LOG.debug(_resp.__dict__)