1+ const logger = require ( 'log4js' ) . getLogger ( "modzy" ) ;
2+ const modzy = require ( 'modzy-sdk' ) ;
3+ const fs = require ( 'fs' ) ;
4+
5+ // Always configure the logger level (ie: all, trace, debug, info, warn, error, fatal)
6+ logger . level = "info" ;
7+
8+ // The system admin can provide the right base API URL, the API key can be downloaded from your profile page on Modzy.
9+ // You can config those params as is described in the readme file (as environment variables, or by using the .env file), or you
10+ // or you can just update the BASE_URL and API_KEY vars and use this sample code (not recommended for production environments).
11+ // The MODZY_BASE_URL should point to the API services route which may be different from the Modzy page URL.
12+ // (ie: https://modzy.example.com/api).
13+ const BASE_URL = process . env . MODZY_BASE_URL ;
14+ // The MODZY_API_KEY is your own personal API key. It is composed by a public part, a dot character and a private part
15+ // (ie: AzQBJ3h4B1z60xNmhAJF.uQyQh8putLIRDi1nOldh).
16+ const API_KEY = process . env . MODZY_API_KEY ;
17+
18+ // Client initialization
19+ // Initialize the ApiClient instance with the BASE_URL and the API_KEY to store those arguments
20+ // for the following API calls.
21+ const modzyClient = new modzy . ModzyClient ( BASE_URL , API_KEY ) ;
22+
23+ // Create a Job with an embedded input, wait, and retrieve results:
24+
25+ async function createJobWithFileInput ( ) {
26+ try {
27+ // Get the model object:
28+ // If you already know the model identifier (i.e.: you got from the URL of the model details page or the input sample),
29+ // you can skip this step. If you don't you can find the model identifier by using its name as follows:
30+ let model = await modzyClient . getModelByName ( "Multi-Language OCR" ) ;
31+ // Or if you already know the model id and want to know more about the model, you can use this instead:
32+ //let model = await modzyClient.getModel("c60c8dbd79");
33+
34+ // The model identifier is under the modelId key. You can take a look at the other keys by uncommenting the following line
35+ logger . info ( Object . keys ( model ) . toString ( ) . replace ( '\n' , ' ' ) ) ;
36+ // Or just log the model identifier and the latest version
37+ logger . info ( `The model identifier is ${ model . modelId } ${ model . latestVersion } ) ;
38+ // Get the model version object:
39+ // If you already know the model version and the input key(s) of the model version you can skip this step. Also, you can
40+ // use the following code block to know about the inputs keys and skip the call on future job submissions.
41+ let modelVersion = await modzyClient . getModelVersion ( model . modelId , model . latestVersion ) ;
42+ // The info stored in modelVersion provides insights about the amount of time that the model can spend processing, the inputs, and
43+ // output keys of the model.
44+ logger . info ( `Ths model version is ${ modelVersion . version } ) ;
45+ logger . info ( ` timeouts: status ${ modelVersion . timeout . status } ${ modelVersion . timeout . run } ) ;
46+ logger . info ( " inputs: " ) ;
47+ for ( key in modelVersion . inputs ) {
48+ let input = modelVersion . inputs [ key ] ;
49+ logger . info ( ` key ${ input . name } ${ input . acceptedMediaTypes } ${ input . description } ) ;
50+ }
51+ logger . info ( " outputs: " )
52+ for ( key in modelVersion . outputs ) {
53+ let output = modelVersion . outputs [ key ] ;
54+ logger . info ( ` key ${ output . name } ${ output . mediaType } ${ output . description } ) ;
55+ }
56+ // Send the job:
57+ // An embedded input is a byte array encoded as a string in Base64, that's very handy for small to middle size files, for
58+ // bigger files can be a memory issue because you need to load the file in memory (load + encode).
59+ const imagePath = 'samples/image.png' ;
60+ const configPath = 'samples/config.json' ;
61+ // With the info about the model (identifier), the model version (version string, input/output keys), you are ready to
62+ // submit the job. Just prepare the source object:
63+ let sources = { "source-key" : { "input" : imagePath , "config.json" : configPath } } ;
64+ // An inference job groups input data that you send to a model. You can send any amount of inputs to
65+ // process and you can identify and refer to a specific input by the key that you assign, for example we can add:
66+ sources [ "second-key" ] = { "input" : imagePath , "config.json" : configPath }
67+ // You don't need to load all the inputs from files, just convert to bytes as follows:
68+ const configBytes = Buffer . from ( JSON . stringify ( { "languages" :[ "spa" ] } ) ) ;
69+ sources [ "another-key" ] = { "input" : imagePath , "config.json" :configBytes }
70+ // If you send a wrong input key, the model fails to process the input.
71+ sources [ "wrong-key" ] = { "a.wrong.key" : imagePath , "config.json" :configPath }
72+ // If you send a correct input key, but some wrong values, the model fails to process the input.
73+ sources [ "wrong-value" ] = { "input" : configPath , "config.json" :imagePath }
74+ // When you have all your inputs ready, you can use our helper method to submit the job as follows:
75+ let job = await modzyClient . submitJobFiles ( model . modelId , modelVersion . version , sources ) ;
76+ // Modzy creates the job and queue for processing. The job object contains all the info that you need to keep track
77+ // of the process, the most important being the job identifier and the job status.
78+ logger . info ( "job: " + job . jobIdentifier + " " + job . status ) ;
79+ // The job moves to SUBMITTED, meaning that Modzy acknowledged the job and sent it to the queue to be processed.
80+ // We provide a helper method to listen until the job finishes processing. it will listen until the job finishes
81+ // and moves to COMPLETED, CANCELED, or TIMEOUT.
82+ job = await modzyClient . blockUntilComplete ( job ) ;
83+ // Get the results:
84+ // Check the status of the job. Jobs may be canceled or may reach a timeout.
85+ if ( job . status === "COMPLETED" ) {
86+ // A completed job means that all the inputs were processed by the model. Check the results for each
87+ // input keys provided in the source object to see the model output.
88+ let result = await modzyClient . getResult ( job . jobIdentifier ) ;
89+ // The result object has some useful info:
90+ logger . info ( `Result: finished: ${ result . finished } ${ result . total } ${ result . completed } ${ result . failed } ) ;
91+ // Notice that we are iterating through the same input sources keys
92+ for ( key in sources ) {
93+ // The result object has the individual results of each job input. In this case the output key is called
94+ // results.json, so we can get the results as follows:
95+ if ( result . results [ key ] ) {
96+ let model_res = result . results [ key ] [ "results.json" ] ;
97+ // The output for this model comes in a JSON format, so we can directly log the model results:
98+ logger . info ( ` ${ key } ${ JSON . stringify ( model_res ) } ) ;
99+ }
100+ else {
101+ logger . warn ( ` ${ key } ${ result . failures [ key ] [ 'error' ] } ) ;
102+ }
103+ }
104+ }
105+ else {
106+ log . warn ( `The job ends with status ${ job . status } ) ;
107+ }
108+ }
109+ catch ( error ) {
110+ logger . warn ( error ) ;
111+ }
112+ }
113+
114+
115+ createJobWithFileInput ( ) ;
0 commit comments