@flyteorg/flyteidl 1.13.3 → 1.13.5

package/gen/pb-js/flyteidl.d.ts

@@ -3385,17 +3385,14 @@ export namespace flyteidl {
             /** Literal map */
             map?: (flyteidl.core.ILiteralMap|null);
 
+            /** Literal offloadedMetadata */
+            offloadedMetadata?: (flyteidl.core.ILiteralOffloadedMetadata|null);
+
             /** Literal hash */
             hash?: (string|null);
 
             /** Literal metadata */
             metadata?: ({ [k: string]: string }|null);
-
-            /** Literal uri */
-            uri?: (string|null);
-
-            /** Literal sizeBytes */
-            sizeBytes?: (Long|null);
         }
 
         /** Represents a Literal. */
@@ -3416,20 +3413,17 @@ export namespace flyteidl {
             /** Literal map. */
             public map?: (flyteidl.core.ILiteralMap|null);
 
+            /** Literal offloadedMetadata. */
+            public offloadedMetadata?: (flyteidl.core.ILiteralOffloadedMetadata|null);
+
             /** Literal hash. */
             public hash: string;
 
             /** Literal metadata. */
             public metadata: { [k: string]: string };
 
-            /** Literal uri. */
-            public uri: string;
-
-            /** Literal sizeBytes. */
-            public sizeBytes: Long;
-
             /** Literal value. */
-            public value?: ("scalar"|"collection"|"map");
+            public value?: ("scalar"|"collection"|"map"|"offloadedMetadata");
 
             /**
              * Creates a new Literal instance using the specified properties.
@@ -3464,6 +3458,70 @@ export namespace flyteidl {
             public static verify(message: { [k: string]: any }): (string|null);
         }
 
+        /** Properties of a LiteralOffloadedMetadata. */
+        interface ILiteralOffloadedMetadata {
+
+            /** LiteralOffloadedMetadata uri */
+            uri?: (string|null);
+
+            /** LiteralOffloadedMetadata sizeBytes */
+            sizeBytes?: (Long|null);
+
+            /** LiteralOffloadedMetadata inferredType */
+            inferredType?: (flyteidl.core.ILiteralType|null);
+        }
+
+        /** Represents a LiteralOffloadedMetadata. */
+        class LiteralOffloadedMetadata implements ILiteralOffloadedMetadata {
+
+            /**
+             * Constructs a new LiteralOffloadedMetadata.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.ILiteralOffloadedMetadata);
+
+            /** LiteralOffloadedMetadata uri. */
+            public uri: string;
+
+            /** LiteralOffloadedMetadata sizeBytes. */
+            public sizeBytes: Long;
+
+            /** LiteralOffloadedMetadata inferredType. */
+            public inferredType?: (flyteidl.core.ILiteralType|null);
+
+            /**
+             * Creates a new LiteralOffloadedMetadata instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns LiteralOffloadedMetadata instance
+             */
+            public static create(properties?: flyteidl.core.ILiteralOffloadedMetadata): flyteidl.core.LiteralOffloadedMetadata;
+
+            /**
+             * Encodes the specified LiteralOffloadedMetadata message. Does not implicitly {@link flyteidl.core.LiteralOffloadedMetadata.verify|verify} messages.
+             * @param message LiteralOffloadedMetadata message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.ILiteralOffloadedMetadata, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a LiteralOffloadedMetadata message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns LiteralOffloadedMetadata
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.LiteralOffloadedMetadata;
+
+            /**
+             * Verifies a LiteralOffloadedMetadata message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+        }
+
         /** Properties of a LiteralCollection. */
         interface ILiteralCollection {
 

package/gen/pb-js/flyteidl.js

@@ -8103,10 +8103,9 @@
                  * @property {flyteidl.core.IScalar|null} [scalar] Literal scalar
                  * @property {flyteidl.core.ILiteralCollection|null} [collection] Literal collection
                  * @property {flyteidl.core.ILiteralMap|null} [map] Literal map
+                 * @property {flyteidl.core.ILiteralOffloadedMetadata|null} [offloadedMetadata] Literal offloadedMetadata
                  * @property {string|null} [hash] Literal hash
                  * @property {Object.<string,string>|null} [metadata] Literal metadata
-                 * @property {string|null} [uri] Literal uri
-                 * @property {Long|null} [sizeBytes] Literal sizeBytes
                  */
     
                 /**
@@ -8149,6 +8148,14 @@
                  */
                 Literal.prototype.map = null;
     
+                /**
+                 * Literal offloadedMetadata.
+                 * @member {flyteidl.core.ILiteralOffloadedMetadata|null|undefined} offloadedMetadata
+                 * @memberof flyteidl.core.Literal
+                 * @instance
+                 */
+                Literal.prototype.offloadedMetadata = null;
+    
                 /**
                  * Literal hash.
                  * @member {string} hash
@@ -8165,33 +8172,17 @@
                  */
                 Literal.prototype.metadata = $util.emptyObject;
     
-                /**
-                 * Literal uri.
-                 * @member {string} uri
-                 * @memberof flyteidl.core.Literal
-                 * @instance
-                 */
-                Literal.prototype.uri = "";
-    
-                /**
-                 * Literal sizeBytes.
-                 * @member {Long} sizeBytes
-                 * @memberof flyteidl.core.Literal
-                 * @instance
-                 */
-                Literal.prototype.sizeBytes = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
-    
                 // OneOf field names bound to virtual getters and setters
                 var $oneOfFields;
     
                 /**
                  * Literal value.
-                 * @member {"scalar"|"collection"|"map"|undefined} value
+                 * @member {"scalar"|"collection"|"map"|"offloadedMetadata"|undefined} value
                  * @memberof flyteidl.core.Literal
                  * @instance
                  */
                 Object.defineProperty(Literal.prototype, "value", {
-                    get: $util.oneOfGetter($oneOfFields = ["scalar", "collection", "map"]),
+                    get: $util.oneOfGetter($oneOfFields = ["scalar", "collection", "map", "offloadedMetadata"]),
                     set: $util.oneOfSetter($oneOfFields)
                 });
     
@@ -8230,10 +8221,8 @@
                     if (message.metadata != null && message.hasOwnProperty("metadata"))
                         for (var keys = Object.keys(message.metadata), i = 0; i < keys.length; ++i)
                             writer.uint32(/* id 5, wireType 2 =*/42).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.metadata[keys[i]]).ldelim();
-                    if (message.uri != null && message.hasOwnProperty("uri"))
-                        writer.uint32(/* id 6, wireType 2 =*/50).string(message.uri);
-                    if (message.sizeBytes != null && message.hasOwnProperty("sizeBytes"))
-                        writer.uint32(/* id 7, wireType 0 =*/56).uint64(message.sizeBytes);
+                    if (message.offloadedMetadata != null && message.hasOwnProperty("offloadedMetadata"))
+                        $root.flyteidl.core.LiteralOffloadedMetadata.encode(message.offloadedMetadata, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
                     return writer;
                 };
     
@@ -8264,6 +8253,9 @@
                         case 3:
                             message.map = $root.flyteidl.core.LiteralMap.decode(reader, reader.uint32());
                             break;
+                        case 8:
+                            message.offloadedMetadata = $root.flyteidl.core.LiteralOffloadedMetadata.decode(reader, reader.uint32());
+                            break;
                         case 4:
                             message.hash = reader.string();
                             break;
@@ -8275,12 +8267,6 @@
                             reader.pos++;
                             message.metadata[key] = reader.string();
                             break;
-                        case 6:
-                            message.uri = reader.string();
-                            break;
-                        case 7:
-                            message.sizeBytes = reader.uint64();
-                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -8329,6 +8315,16 @@
                                 return "map." + error;
                         }
                     }
+                    if (message.offloadedMetadata != null && message.hasOwnProperty("offloadedMetadata")) {
+                        if (properties.value === 1)
+                            return "value: multiple values";
+                        properties.value = 1;
+                        {
+                            var error = $root.flyteidl.core.LiteralOffloadedMetadata.verify(message.offloadedMetadata);
+                            if (error)
+                                return "offloadedMetadata." + error;
+                        }
+                    }
                     if (message.hash != null && message.hasOwnProperty("hash"))
                         if (!$util.isString(message.hash))
                             return "hash: string expected";
@@ -8340,16 +8336,156 @@
                             if (!$util.isString(message.metadata[key[i]]))
                                 return "metadata: string{k:string} expected";
                     }
+                    return null;
+                };
+    
+                return Literal;
+            })();
+    
+            core.LiteralOffloadedMetadata = (function() {
+    
+                /**
+                 * Properties of a LiteralOffloadedMetadata.
+                 * @memberof flyteidl.core
+                 * @interface ILiteralOffloadedMetadata
+                 * @property {string|null} [uri] LiteralOffloadedMetadata uri
+                 * @property {Long|null} [sizeBytes] LiteralOffloadedMetadata sizeBytes
+                 * @property {flyteidl.core.ILiteralType|null} [inferredType] LiteralOffloadedMetadata inferredType
+                 */
+    
+                /**
+                 * Constructs a new LiteralOffloadedMetadata.
+                 * @memberof flyteidl.core
+                 * @classdesc Represents a LiteralOffloadedMetadata.
+                 * @implements ILiteralOffloadedMetadata
+                 * @constructor
+                 * @param {flyteidl.core.ILiteralOffloadedMetadata=} [properties] Properties to set
+                 */
+                function LiteralOffloadedMetadata(properties) {
+                    if (properties)
+                        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null)
+                                this[keys[i]] = properties[keys[i]];
+                }
+    
+                /**
+                 * LiteralOffloadedMetadata uri.
+                 * @member {string} uri
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @instance
+                 */
+                LiteralOffloadedMetadata.prototype.uri = "";
+    
+                /**
+                 * LiteralOffloadedMetadata sizeBytes.
+                 * @member {Long} sizeBytes
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @instance
+                 */
+                LiteralOffloadedMetadata.prototype.sizeBytes = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
+    
+                /**
+                 * LiteralOffloadedMetadata inferredType.
+                 * @member {flyteidl.core.ILiteralType|null|undefined} inferredType
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @instance
+                 */
+                LiteralOffloadedMetadata.prototype.inferredType = null;
+    
+                /**
+                 * Creates a new LiteralOffloadedMetadata instance using the specified properties.
+                 * @function create
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @static
+                 * @param {flyteidl.core.ILiteralOffloadedMetadata=} [properties] Properties to set
+                 * @returns {flyteidl.core.LiteralOffloadedMetadata} LiteralOffloadedMetadata instance
+                 */
+                LiteralOffloadedMetadata.create = function create(properties) {
+                    return new LiteralOffloadedMetadata(properties);
+                };
+    
+                /**
+                 * Encodes the specified LiteralOffloadedMetadata message. Does not implicitly {@link flyteidl.core.LiteralOffloadedMetadata.verify|verify} messages.
+                 * @function encode
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @static
+                 * @param {flyteidl.core.ILiteralOffloadedMetadata} message LiteralOffloadedMetadata message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                LiteralOffloadedMetadata.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.uri != null && message.hasOwnProperty("uri"))
+                        writer.uint32(/* id 1, wireType 2 =*/10).string(message.uri);
+                    if (message.sizeBytes != null && message.hasOwnProperty("sizeBytes"))
+                        writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.sizeBytes);
+                    if (message.inferredType != null && message.hasOwnProperty("inferredType"))
+                        $root.flyteidl.core.LiteralType.encode(message.inferredType, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+                    return writer;
+                };
+    
+                /**
+                 * Decodes a LiteralOffloadedMetadata message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {flyteidl.core.LiteralOffloadedMetadata} LiteralOffloadedMetadata
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                LiteralOffloadedMetadata.decode = function decode(reader, length) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    var end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.LiteralOffloadedMetadata();
+                    while (reader.pos < end) {
+                        var tag = reader.uint32();
+                        switch (tag >>> 3) {
+                        case 1:
+                            message.uri = reader.string();
+                            break;
+                        case 2:
+                            message.sizeBytes = reader.uint64();
+                            break;
+                        case 3:
+                            message.inferredType = $root.flyteidl.core.LiteralType.decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Verifies a LiteralOffloadedMetadata message.
+                 * @function verify
+                 * @memberof flyteidl.core.LiteralOffloadedMetadata
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                LiteralOffloadedMetadata.verify = function verify(message) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
                     if (message.uri != null && message.hasOwnProperty("uri"))
                         if (!$util.isString(message.uri))
                             return "uri: string expected";
                     if (message.sizeBytes != null && message.hasOwnProperty("sizeBytes"))
                         if (!$util.isInteger(message.sizeBytes) && !(message.sizeBytes && $util.isInteger(message.sizeBytes.low) && $util.isInteger(message.sizeBytes.high)))
                             return "sizeBytes: integer|Long expected";
+                    if (message.inferredType != null && message.hasOwnProperty("inferredType")) {
+                        var error = $root.flyteidl.core.LiteralType.verify(message.inferredType);
+                        if (error)
+                            return "inferredType." + error;
+                    }
                     return null;
                 };
     
-                return Literal;
+                return LiteralOffloadedMetadata;
             })();
     
             core.LiteralCollection = (function() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flyteorg/flyteidl",
-  "version": "1.13.3",
+  "version": "1.13.5",
   "description": "Compiled protocol buffers and gRPC service clients/servers for Flyte IDLs",
   "repository": {
     "type": "git",

package/protos/flyteidl/core/literals.proto

@@ -42,8 +42,8 @@ message BlobMetadata {
 // A simple byte array with a tag to help different parts of the system communicate about what is in the byte array.
 // It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data.
 message Binary {
-    bytes value = 1;
-    string tag = 2;
+    bytes value = 1; // Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict.
+    string tag = 2; // The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization.
 }
 
 // A strongly typed schema that defines the interface of data retrieved from the underlying storage medium.
@@ -93,6 +93,7 @@ message Scalar {
 
 // A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives.
 message Literal {
+    reserved 6, 7;
     oneof value {
         // A simple value.
         Scalar scalar = 1;
@@ -102,6 +103,10 @@ message Literal {
 
         // A map of strings to literals.
         LiteralMap map = 3;
+
+        // Offloaded literal metadata
+        // When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata.
+        LiteralOffloadedMetadata offloaded_metadata = 8;
     }
 
     // A hash representing this literal.
@@ -111,12 +116,18 @@ message Literal {
 
     // Additional metadata for literals.
     map<string, string> metadata = 5;
+}
+
+// A message that contains the metadata of the offloaded data.
+message LiteralOffloadedMetadata {
+    // The location of the offloaded core.Literal.
+    string uri = 1;
 
-    // If this literal is offloaded, this field will contain metadata including the offload location.
-    string uri = 6;
+    // The size of the offloaded data.
+    uint64 size_bytes = 2;
 
-    // Includes information about the size of the literal.
-    uint64 size_bytes = 7;
+    // The inferred literal type of the offloaded data.
+    LiteralType inferred_type = 3;
 }
 
 // A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field.