modal 0.3.3 → 0.3.5

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+
 declare class Image {
     readonly imageId: string;
     constructor(imageId: string);
@@ -93,8 +95,114 @@ declare class App {
     imageFromRegistry(tag: string): Promise<Image>;
 }
 
+declare enum FunctionCallInvocationType {
+    FUNCTION_CALL_INVOCATION_TYPE_UNSPECIFIED = 0,
+    FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY = 1,
+    FUNCTION_CALL_INVOCATION_TYPE_ASYNC_LEGACY = 2,
+    FUNCTION_CALL_INVOCATION_TYPE_ASYNC = 3,
+    FUNCTION_CALL_INVOCATION_TYPE_SYNC = 4,
+    UNRECOGNIZED = -1
+}
+declare enum ParameterType {
+    PARAM_TYPE_UNSPECIFIED = 0,
+    PARAM_TYPE_STRING = 1,
+    PARAM_TYPE_INT = 2,
+    /** PARAM_TYPE_PICKLE - currently unused */
+    PARAM_TYPE_PICKLE = 3,
+    PARAM_TYPE_BYTES = 4,
+    /** PARAM_TYPE_UNKNOWN - used in schemas to signify unrecognized or un-annotated types */
+    PARAM_TYPE_UNKNOWN = 5,
+    PARAM_TYPE_LIST = 6,
+    PARAM_TYPE_DICT = 7,
+    PARAM_TYPE_NONE = 8,
+    PARAM_TYPE_BOOL = 9,
+    UNRECOGNIZED = -1
+}
+/** TODO: rename into NamedPayloadType or similar */
+interface ClassParameterSpec {
+    name: string;
+    /** TODO: deprecate - use full_type instead */
+    type: ParameterType;
+    hasDefault: boolean;
+    /** Default *values* are only registered for class parameters */
+    stringDefault?: string | undefined;
+    intDefault?: number | undefined;
+    pickleDefault?: Uint8Array | undefined;
+    bytesDefault?: Uint8Array | undefined;
+    boolDefault?: boolean | undefined;
+    /** supersedes `type` */
+    fullType: GenericPayloadType | undefined;
+}
+declare const ClassParameterSpec: MessageFns<ClassParameterSpec>;
+interface GenericPayloadType {
+    baseType: ParameterType;
+    /** sub-type for generic types like lists */
+    subTypes: GenericPayloadType[];
+}
+declare const GenericPayloadType: MessageFns<GenericPayloadType>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+
+type FunctionCallGetOptions = {
+    timeout?: number;
+};
+type FunctionCallCancelOptions = {
+    terminateContainers?: boolean;
+};
+/**
+ * Represents a Modal FunctionCall. Function Calls are Function invocations with
+ * a given input. They can be consumed asynchronously (see `get()`) or cancelled
+ * (see `cancel()`).
+ */
+declare class FunctionCall {
+    readonly functionCallId: string;
+    constructor(functionCallId: string);
+    /** Create a new function call from ID. */
+    fromId(functionCallId: string): FunctionCall;
+    /** Get the result of a function call, optionally waiting with a timeout. */
+    get(options?: FunctionCallGetOptions): Promise<any>;
+    /** Cancel a running function call. */
+    cancel(options?: FunctionCallCancelOptions): Promise<void>;
+}
+
+/** Represents a deployed Modal Function, which can be invoked remotely. */
+declare class Function_ {
+    readonly functionId: string;
+    readonly methodName: string | undefined;
+    constructor(functionId: string, methodName?: string);
+    static lookup(appName: string, name: string, options?: LookupOptions): Promise<Function_>;
+    remote(args?: any[], kwargs?: Record<string, any>): Promise<any>;
+    spawn(args?: any[], kwargs?: Record<string, any>): Promise<FunctionCall>;
+    execFunctionCall(args?: any[], kwargs?: Record<string, any>, invocationType?: FunctionCallInvocationType): Promise<string>;
+}
+
+/** Represents a deployed Modal Cls. */
+declare class Cls {
+    #private;
+    constructor(serviceFunctionId: string, schema: ClassParameterSpec[], methodNames: string[]);
+    static lookup(appName: string, name: string, options?: LookupOptions): Promise<Cls>;
+    /** Create a new instance of the Cls with parameters. */
+    instance(params?: Record<string, any>): Promise<ClsInstance>;
+}
+/** Represents an instance of a deployed Modal Cls, optionally with parameters. */
+declare class ClsInstance {
+    #private;
+    constructor(methods: Map<string, Function_>);
+    method(name: string): Function_;
+}
+
 /** Function execution exceeds the allowed time limit. */
-declare class TimeoutError extends Error {
+declare class FunctionTimeoutError extends Error {
     constructor(message: string);
 }
 /** An error on the Modal server, or a Python exception. */
@@ -105,13 +213,9 @@ declare class RemoteError extends Error {
 declare class InternalFailure extends Error {
     constructor(message: string);
 }
-
-/** Represents a deployed Modal Function, which can be invoked remotely. */
-declare class Function_ {
-    readonly functionId: string;
-    constructor(functionId: string);
-    static lookup(appName: string, name: string, options?: LookupOptions): Promise<Function_>;
-    remote(args?: any[], kwargs?: Record<string, any>): Promise<any>;
+/** Some resource was not found. */
+declare class NotFoundError extends Error {
+    constructor(message: string);
 }
 
-export { App, Function_, Image, InternalFailure, type LookupOptions, RemoteError, Sandbox, type SandboxCreateOptions, type StdioBehavior, type StreamMode, TimeoutError };
+export { App, Cls, ClsInstance, FunctionCall, type FunctionCallCancelOptions, type FunctionCallGetOptions, FunctionTimeoutError, Function_, Image, InternalFailure, type LookupOptions, NotFoundError, RemoteError, Sandbox, type SandboxCreateOptions, type StdioBehavior, type StreamMode };