Twitter / X api: binary media upload

[WolfgangHG]

The twitter openapi file ( https://api.twitter.com/2/openapi.json ) defines an endpoint to upload media. It seems the Kiota generated client code does not work.

Description of the endpoint: https://docs.x.com/x-api/media/upload-media

This seems to be the relevant part of the openapi description:

Path:

    "/2/media/upload" : {
      ...
      "post" : {
        ...
        "summary" : "Upload media",
        "description" : "Uploads a media file for use in posts or other content.",
        "externalDocs" : {
          "url" : "https://docs.x.com/x-api/media/media-upload"
        },
        "operationId" : "mediaUpload",
        "parameters" : [ ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/MediaUploadRequestOneShot"
              }
            },
            "multipart/form-data" : {
              "schema" : {
                "$ref" : "#/components/schemas/MediaUploadRequestOneShot"
              }
            }
          }
        },
        ...
        }
      }
    },

Components:

      "MediaUploadRequestOneShot" : {
        "type" : "object",
        "required" : [
          "media",
          "media_category"
        ],
        "properties" : {
          "additional_owners" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/UserId"
            }
          },
          "media" : {
            "anyOf" : [
              {
                "$ref" : "#/components/schemas/MediaPayloadBinary"
              },
              {
                "$ref" : "#/components/schemas/MediaPayloadByte"
              }
            ]
          },
          "media_category" : {
            "$ref" : "#/components/schemas/MediaCategoryOneShot"
          },
          "media_type" : {
            "type" : "string",
            "description" : "The type of image or subtitle.",
            "enum" : [
              "text/srt",
              "text/vtt",
              "image/jpeg",
              "image/bmp",
              "image/png",
              "image/webp",
              "image/pjpeg",
              "image/tiff"
            ],
            "example" : "image/png"
          },
          "shared" : {
            "type" : "boolean",
            "description" : "Whether this media is shared or not.",
            "default" : false
          }
        },
        "additionalProperties" : false
      },

      "MediaPayloadBinary" : {
        "type" : "string",
        "description" : "The file to upload.",
        "format" : "binary"
      },
      "MediaPayloadByte" : {
        "type" : "string",
        "description" : "The file to upload.",
        "format" : "byte"
      },

Kiota creates classes MediaUploadRequestOneShot, MediaUploadRequestOneShot_media, MediaPayloadBinary and MediaPayloadByte, but the latter two don't have any properties.

Here is a slightly simplified version (for better readability, I removed "#if" declarations and namespaces)

  public partial class MediaUploadRequestOneShot : IParsable
  {
    public List<string> AdditionalOwners { get; set; }

    public MediaUploadRequestOneShot.MediaUploadRequestOneShot_media Media { get; set; }
    public MediaCategoryOneShot? MediaCategory { get; set; }
    public MediaUploadRequestOneShot_media_type? MediaType { get; set; }
    public bool? Shared { get; set; }
    
    public static MediaUploadRequestOneShot CreateFromDiscriminatorValue(IParseNode parseNode)
    {
      if (ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
      return new MediaUploadRequestOneShot();
    }
    
    public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
    {
      return new Dictionary<string, Action<IParseNode>>
            {
                { "additional_owners", n => { AdditionalOwners = n.GetCollectionOfPrimitiveValues<string>()?.AsList(); } },
                { "media", n => { Media = n.GetObjectValue<MediaUploadRequestOneShot.MediaUploadRequestOneShot_media>(MediaUploadRequestOneShot.MediaUploadRequestOneShot_media.CreateFromDiscriminatorValue); } },
                { "media_category", n => { MediaCategory = n.GetEnumValue<MediaCategoryOneShot>(); } },
                { "media_type", n => { MediaType = n.GetEnumValue<MediaUploadRequestOneShot_media_type>(); } },
                { "shared", n => { Shared = n.GetBoolValue(); } },
            };
    }
    
    public virtual void Serialize(ISerializationWriter writer)
    {
      if (ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
      writer.WriteCollectionOfPrimitiveValues<string>("additional_owners", AdditionalOwners);
      writer.WriteObjectValue<MediaUploadRequestOneShot.MediaUploadRequestOneShot_media>("media", Media);
      writer.WriteEnumValue<MediaCategoryOneShot>("media_category", MediaCategory);
      writer.WriteEnumValue<MediaUploadRequestOneShot_media_type>("media_type", MediaType);
      writer.WriteBoolValue("shared", Shared);
    }

    public partial class MediaUploadRequestOneShot_media : IComposedTypeWrapper, IParsable
    {
      public MediaPayloadBinary MediaPayloadBinary { get; set; }

      public MediaPayloadByte MediaPayloadByte { get; set; }

      public static MediaUploadRequestOneShot.MediaUploadRequestOneShot_media CreateFromDiscriminatorValue(IParseNode parseNode)
      {
        if (ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
        var result = new MediaUploadRequestOneShot.MediaUploadRequestOneShot_media();
        result.MediaPayloadBinary = new MediaPayloadBinary();
        result.MediaPayloadByte = new MediaPayloadByte();
        return result;
      }

      public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
      {
        if (MediaPayloadBinary != null || MediaPayloadByte != null)
        {
          return ParseNodeHelper.MergeDeserializersForIntersectionWrapper(MediaPayloadBinary, MediaPayloadByte);
        }
        return new Dictionary<string, Action<IParseNode>>();
      }

      public virtual void Serialize(ISerializationWriter writer)
      {
        if (ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
        writer.WriteObjectValue<MediaPayloadBinary>(null, MediaPayloadBinary, MediaPayloadByte);
      }
    }
  }

  public partial class MediaPayloadBinary : IAdditionalDataHolder, IParsable
  {
    public IDictionary<string, object> AdditionalData { get; set; }
    
    public MediaPayloadBinary()
    {
      AdditionalData = new Dictionary<string, object>();
    }

    public static MediaPayloadBinary CreateFromDiscriminatorValue(IParseNode parseNode)
    {
      if (ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
      return new MediaPayloadBinary();
    }

    public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
    {
      return new Dictionary<string, Action<IParseNode>>
      {
      };
    }

    public virtual void Serialize(ISerializationWriter writer)
    {
      if (ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
      writer.WriteAdditionalData(AdditionalData);
    }
  }
}

Generating the client prints (among others) those two warnings, which seem to be related:

warn: Kiota.Builder.KiotaBuilder[0]
      Discriminator MediaPayloadBinary is not inherited from MediaPayloadBinary.
warn: Kiota.Builder.KiotaBuilder[0]
      Discriminator MediaPayloadByte is not inherited from MediaPayloadByte.

Is there something missing in Kiota, or are additional steps required to upload the media to X?

[WolfgangHG]

I could do a working file upload with those changes to "MediaUploadRequestOneShot":

 public partial class MediaUploadRequestOneShot : IParsable
  {
    public List<string> AdditionalOwners { get; set; }

    public byte[] Media { get; set; }
    public MediaCategoryOneShot? MediaCategory { get; set; }
    public MediaUploadRequestOneShot_media_type? MediaType { get; set; }
    public bool? Shared { get; set; }
    
    public static MediaUploadRequestOneShot CreateFromDiscriminatorValue(IParseNode parseNode)
    {
      if (ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
      return new MediaUploadRequestOneShot();
    }
    
    public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
    {
      return new Dictionary<string, Action<IParseNode>>
            {
                { "additional_owners", n => { AdditionalOwners = n.GetCollectionOfPrimitiveValues<string>()?.AsList(); } },
                { "media", n => { Media = n.GetByteArrayValue(); } },
                { "media_category", n => { MediaCategory = n.GetEnumValue<MediaCategoryOneShot>(); } },
                { "media_type", n => { MediaType = n.GetEnumValue<MediaUploadRequestOneShot_media_type>(); } },
                { "shared", n => { Shared = n.GetBoolValue(); } },
            };
    }
    
    public virtual void Serialize(ISerializationWriter writer)
    {
      if (ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
      writer.WriteCollectionOfPrimitiveValues<string>("additional_owners", AdditionalOwners);
      writer.WriteByteArrayValue("media", Media);
      writer.WriteEnumValue<MediaCategoryOneShot>("media_category", MediaCategory);
      writer.WriteEnumValue<MediaUploadRequestOneShot_media_type>("media_type", MediaType);
      writer.WriteBoolValue("shared", Shared);
    }

I converted the property "media" to byte[] and also changed serialization/deserialization.

Now, the request contains a base64 string and I can confirm that it works.

But I don't know whether the X openapi description is correct or not and how Kiota should handle it. So I am far away from creating a feature request issue. Hopefully someone can comment on this problem.

[WolfgangHG]

That's interesting: the endpoint upload chunked file follows the same concept, but here Kiota creates a byte[] property and everything works as expected.

This is the OpenAPI definition:

      "MediaUploadAppendRequest" : {
        "anyOf" : [
          {
            "type" : "object",
            "required" : [
              "media",
              "segment_index"
            ],
            "properties" : {
              "media" : {
                "$ref" : "#/components/schemas/MediaPayloadBinary"
              },
              "segment_index" : {
                "$ref" : "#/components/schemas/MediaSegments"
              }
            }
          },
          {
            "type" : "object",
            "required" : [
              "media",
              "segment_index"
            ],
            "properties" : {
              "media" : {
                "$ref" : "#/components/schemas/MediaPayloadByte"
              },
              "segment_index" : {
                "$ref" : "#/components/schemas/MediaSegments"
              }
            }
          }
        ]
      },
      ...
      "MediaPayloadBinary" : {
        "type" : "string",
        "description" : "The file to upload.",
        "format" : "binary"
      },
      "MediaPayloadByte" : {
        "type" : "string",
        "description" : "The file to upload.",
        "format" : "byte"
      },

Here, Kiota creates byte[] properties (simplified code):

public partial class MediaUploadAppendRequest : IComposedTypeWrapper, IParsable
{
  public global::XbyOpenApi.Core.Client.Models.MediaUploadAppendRequestMember1 MediaUploadAppendRequestMember1 { get; set; }
  public global::XbyOpenApi.Core.Client.Models.MediaUploadAppendRequestMember2 MediaUploadAppendRequestMember2 { get; set; }
}

public partial class MediaUploadAppendRequestMember1 : IAdditionalDataHolder, IParsable
{
  public byte[] Media { get; set; }
}
    
public partial class MediaUploadAppendRequestMember2 : IAdditionalDataHolder, IParsable
{
  public byte[] Media { get; set; }
}

So, the first OpenAPI definition somehow causes Kiota to create wrong code. I hope that one of the devs reads this, otherwise I will create an issue in the future.

[WolfgangHG]

I created #7338 with a stripped down version of the X api spec. Might be a X error or a Kiota problem....