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 input 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+ // A file input can be a byte array or any file path. This input type fits files of any size.
58+ const imagePath = 'samples/image.png' ;
59+ const configPath = 'samples/config.json' ;
60+ // With the info about the model (identifier), the model version (version string, input/output keys), you are ready to
61+ // submit the job. Just prepare the source object:
62+ let sources = { "source-key" : { "input" : imagePath , "config.json" : configPath } } ;
63+ // An inference job groups input data that you send to a model. You can send any amount of inputs to
64+ // process and you can identify and refer to a specific input by the key that you assign, for example we can add:
65+ sources [ "second-key" ] = { "input" : imagePath , "config.json" : configPath }
66+ // You don’t need to load all the inputs from the files, just convert to bytes as follows:
67+ const configBytes = Buffer . from ( JSON . stringify ( { "languages" :[ "spa" ] } ) ) ;
68+ sources [ "another-key" ] = { "input" : imagePath , "config.json" :configBytes }
69+ // If you send an incorrect input key, the model fails to process the input.
70+ sources [ "wrong-key" ] = { "a.wrong.key" : imagePath , "config.json" :configPath }
71+ // If you send a correct input key, but some wrong values, the model fails to process the input.
72+ sources [ "wrong-value" ] = { "input" : configPath , "config.json" :imagePath }
73+ // When you have all your inputs ready, you can use our helper method to submit the job as follows:
74+ let job = await modzyClient . submitJobFiles ( model . modelId , modelVersion . version , sources ) ;
75+ // Modzy creates the job and queue for processing. The job object contains all the info that you need to keep track
76+ // of the process, the most important being the job identifier and the job status.
77+ logger . info ( "job: " + job . jobIdentifier + " " + job . status ) ;
78+ // The job moves to SUBMITTED, meaning that Modzy acknowledged the job and sent it to the queue to be processed.
79+ // We provide a helper method to listen until the job finishes processing. It will listen until the job finishes
80+ // and moves to COMPLETED, CANCELED, or TIMEOUT.
81+ job = await modzyClient . blockUntilComplete ( job ) ;
82+ // Get the results:
83+ // Check the status of the job. Jobs may be canceled or may reach a timeout.
84+ if ( job . status === "COMPLETED" ) {
85+ // A completed job means that all the inputs were processed by the model. Check the results for each
86+ // input key provided in the source object to see the model output.
87+ let result = await modzyClient . getResult ( job . jobIdentifier ) ;
88+ // The result object has some useful info:
89+ logger . info ( `Result: finished: ${ result . finished } ${ result . total } ${ result . completed } ${ result . failed } ) ;
90+ // Notice that we are iterating through the same input sources keys
91+ for ( key in sources ) {
92+ // The result object has the individual results of each job input. In this case, the output key is called
93+ // results.json, so we can get the results as follows:
94+ if ( result . results [ key ] ) {
95+ let model_res = result . results [ key ] [ "results.json" ] ;
96+ // The output for this model comes in a JSON format, so we can directly log the model results:
97+ logger . info ( ` ${ key } ${ JSON . stringify ( model_res ) } ) ;
98+ }
99+ else {
100+ logger . warn ( ` ${ key } ${ result . failures [ key ] [ 'error' ] } ) ;
101+ }
102+ }
103+ }
104+ else {
105+ log . warn ( `The job ends with status ${ job . status } ) ;
106+ }
107+ }
108+ catch ( error ) {
109+ logger . warn ( error ) ;
110+ }
111+ }
112+
113+
114+ createJobWithFileInput ( ) ;
0 commit comments