docs: def createArtifact(self, *args, **kwargs):
          """
          Create Artifact
  
          This API end-point creates an artifact for a specific run of a task. This
          should **only** be used by a worker currently operating on this task, or
          from a process running within the task (ie. on the worker).
  
          All artifacts must specify when they `expires`, the queue will
          automatically take care of deleting artifacts past their
          expiration point. This features makes it feasible to upload large
          intermediate artifacts from data processing applications, as the
          artifacts can be set to expire a few days later.
  
          We currently support 3 different `storageType`s, each storage type have
          slightly different features and in some cases difference semantics.
          We also have 2 deprecated `storageType`s which are only maintained for
          backwards compatiability and should not be used in new implementations
  
          **Blob artifacts**, are useful for storing large files.  Currently, these
          are all stored in S3 but there are facilities for adding support for other
          backends in futre.  A call for this type of artifact must provide information
          about the file which will be uploaded.  This includes sha256 sums and sizes.
          This method will return a list of general form HTTP requests which are signed
          by AWS S3 credentials managed by the Queue.  Once these requests are completed
          the list of `ETag` values returned by the requests must be passed to the
          queue `completeArtifact` method
  
          **S3 artifacts**, DEPRECATED is useful for static files which will be
          stored on S3. When creating an S3 artifact the queue will return a
          pre-signed URL to which you can do a `PUT` request to upload your
          artifact. Note that `PUT` request **must** specify the `content-length`
          header and **must** give the `content-type` header the same value as in
          the request to `createArtifact`.
  
          **Azure artifacts**, DEPRECATED are stored in _Azure Blob Storage_ service
          which given the consistency guarantees and API interface offered by Azure
          is more suitable for artifacts that will be modified during the execution
          of the task. For example docker-worker has a feature that persists the
          task log to Azure Blob Storage every few seconds creating a somewhat
          live log. A request to create an Azure artifact will return a URL
          featuring a [Shared-Access-Signature](http://msdn.microsoft.com/en-us/library/azure/dn140256.aspx),
          refer to MSDN for further information on how to use these.
          **Warning: azure artifact is currently an experimental feature subject
          to changes and data-drops.**
  
          **Reference artifacts**, only consists of meta-data which the queue will
          store for you. These artifacts really only have a `url` property and
          when the artifact is requested the client will be redirect the URL
          provided with a `303` (See Other) redirect. Please note that we cannot
          delete artifacts you upload to other service, we can only delete the
          reference to the artifact, when it expires.
  
          **Error artifacts**, only consists of meta-data which the queue will
          store for you. These artifacts are only meant to indicate that you the
          worker or the task failed to generate a specific artifact, that you
          would otherwise have uploaded. For example docker-worker will upload an
          error artifact, if the file it was supposed to upload doesn't exists or
          turns out to be a directory. Clients requesting an error artifact will
          get a `424` (Failed Dependency) response. This is mainly designed to
          ensure that dependent tasks can distinguish between artifacts that were
          suppose to be generated and artifacts for which the name is misspelled.
  
          **Artifact immutability**, generally speaking you cannot overwrite an
          artifact when created. But if you repeat the request with the same
          properties the request will succeed as the operation is idempotent.
          This is useful if you need to refresh a signed URL while uploading.
          Do not abuse this to overwrite artifacts created by another entity!
          Such as worker-host overwriting artifact created by worker-code.
  
          As a special case the `url` property on _reference artifacts_ can be
          updated. You should only use this to update the `url` property for
          reference artifacts your process has created.
  
          This method takes input: ``v1/post-artifact-request.json#``
  
          This method gives output: ``v1/post-artifact-response.json#``
  
          This method is ``stable``
          """
  
          return self._makeApiCall(self.funcinfo["createArtifact"], *args, **kwargs)