/**
 * @license
 * Copyright 2018 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * IOHandler implementations based on HTTP requests in the web browser.
 *
 * Uses [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
 */
import { env } from '../environment';
import { assert } from '../util';
import { getModelArtifactsForJSON, getModelArtifactsInfoForJSON, getModelJSONForModelArtifacts, getWeightSpecs } from './io_utils';
import { CompositeArrayBuffer } from './composite_array_buffer';
import { IORouterRegistry } from './router_registry';
import { loadWeightsAsArrayBuffer, streamWeights } from './weights_loader';
const OCTET_STREAM_MIME_TYPE = 'application/octet-stream';
const JSON_TYPE = 'application/json';
class HTTPRequest {
    constructor(path, loadOptions) {
        this.DEFAULT_METHOD = 'POST';
        if (loadOptions == null) {
            loadOptions = {};
        }
        this.weightPathPrefix = loadOptions.weightPathPrefix;
        this.weightUrlConverter = loadOptions.weightUrlConverter;
        if (loadOptions.fetchFunc != null) {
            assert(typeof loadOptions.fetchFunc === 'function', () => 'Must pass a function that matches the signature of ' +
                '`fetch` (see ' +
                'https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)');
            this.fetch = loadOptions.fetchFunc;
        }
        else {
            this.fetch = env().platform.fetch;
        }
        assert(path != null && path.length > 0, () => 'URL path for http must not be null, undefined or ' +
            'empty.');
        if (Array.isArray(path)) {
            assert(path.length === 2, () => 'URL paths for http must have a length of 2, ' +
                `(actual length is ${path.length}).`);
        }
        this.path = path;
        if (loadOptions.requestInit != null &&
            loadOptions.requestInit.body != null) {
            throw new Error('requestInit is expected to have no pre-existing body, but has one.');
        }
        this.requestInit = loadOptions.requestInit || {};
        this.loadOptions = loadOptions;
    }
    async save(modelArtifacts) {
        if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
            throw new Error('BrowserHTTPRequest.save() does not support saving model topology ' +
                'in binary formats yet.');
        }
        const init = Object.assign({ method: this.DEFAULT_METHOD }, this.requestInit);
        init.body = new FormData();
        const weightsManifest = [{
                paths: ['./model.weights.bin'],
                weights: modelArtifacts.weightSpecs,
            }];
        const modelTopologyAndWeightManifest = getModelJSONForModelArtifacts(modelArtifacts, weightsManifest);
        init.body.append('model.json', new Blob([JSON.stringify(modelTopologyAndWeightManifest)], { type: JSON_TYPE }), 'model.json');
        if (modelArtifacts.weightData != null) {
            // TODO(mattsoulanille): Support saving models over 2GB that exceed
            // Chrome's ArrayBuffer size limit.
            const weightBuffer = CompositeArrayBuffer.join(modelArtifacts.weightData);
            init.body.append('model.weights.bin', new Blob([weightBuffer], { type: OCTET_STREAM_MIME_TYPE }), 'model.weights.bin');
        }
        const response = await this.fetch(this.path, init);
        if (response.ok) {
            return {
                modelArtifactsInfo: getModelArtifactsInfoForJSON(modelArtifacts),
                responses: [response],
            };
        }
        else {
            throw new Error(`BrowserHTTPRequest.save() failed due to HTTP response status ` +
                `${response.status}.`);
        }
    }
    async loadModelJSON() {
        const modelConfigRequest = await this.fetch(this.path, this.requestInit);
        if (!modelConfigRequest.ok) {
            throw new Error(`Request to ${this.path} failed with status code ` +
                `${modelConfigRequest.status}. Please verify this URL points to ` +
                `the model JSON of the model to load.`);
        }
        let modelJSON;
        try {
            modelJSON = await modelConfigRequest.json();
        }
        catch (e) {
            let message = `Failed to parse model JSON of response from ${this.path}.`;
            // TODO(nsthorat): Remove this after some time when we're comfortable that
            // .pb files are mostly gone.
            if (this.path.endsWith('.pb')) {
                message += ' Your path contains a .pb file extension. ' +
                    'Support for .pb models have been removed in TensorFlow.js 1.0 ' +
                    'in favor of .json models. You can re-convert your Python ' +
                    'TensorFlow model using the TensorFlow.js 1.0 conversion scripts ' +
                    'or you can convert your.pb models with the \'pb2json\'' +
                    'NPM script in the tensorflow/tfjs-converter repository.';
            }
            else {
                message += ' Please make sure the server is serving valid ' +
                    'JSON for this request.';
            }
            throw new Error(message);
        }
        // We do not allow both modelTopology and weightsManifest to be missing.
        const modelTopology = modelJSON.modelTopology;
        const weightsManifest = modelJSON.weightsManifest;
        if (modelTopology == null && weightsManifest == null) {
            throw new Error(`The JSON from HTTP path ${this.path} contains neither model ` +
                `topology or manifest for weights.`);
        }
        return modelJSON;
    }
    /**
     * Load model artifacts via HTTP request(s).
     *
     * See the documentation to `tf.io.http` for details on the saved
     * artifacts.
     *
     * @returns The loaded model artifacts (if loading succeeds).
     */
    async load() {
        if (this.loadOptions.streamWeights) {
            return this.loadStream();
        }
        const modelJSON = await this.loadModelJSON();
        return getModelArtifactsForJSON(modelJSON, (weightsManifest) => this.loadWeights(weightsManifest));
    }
    async loadStream() {
        const modelJSON = await this.loadModelJSON();
        const fetchURLs = await this.getWeightUrls(modelJSON.weightsManifest);
        const weightSpecs = getWeightSpecs(modelJSON.weightsManifest);
        const stream = () => streamWeights(fetchURLs, this.loadOptions);
        return Object.assign(Object.assign({}, modelJSON), { weightSpecs, getWeightStream: stream });
    }
    async getWeightUrls(weightsManifest) {
        const weightPath = Array.isArray(this.path) ? this.path[1] : this.path;
        const [prefix, suffix] = parseUrl(weightPath);
        const pathPrefix = this.weightPathPrefix || prefix;
        const fetchURLs = [];
        const urlPromises = [];
        for (const weightsGroup of weightsManifest) {
            for (const path of weightsGroup.paths) {
                if (this.weightUrlConverter != null) {
                    urlPromises.push(this.weightUrlConverter(path));
                }
                else {
                    fetchURLs.push(pathPrefix + path + suffix);
                }
            }
        }
        if (this.weightUrlConverter) {
            fetchURLs.push(...await Promise.all(urlPromises));
        }
        return fetchURLs;
    }
    async loadWeights(weightsManifest) {
        const fetchURLs = await this.getWeightUrls(weightsManifest);
        const weightSpecs = getWeightSpecs(weightsManifest);
        const buffers = await loadWeightsAsArrayBuffer(fetchURLs, this.loadOptions);
        return [weightSpecs, buffers];
    }
}
HTTPRequest.URL_SCHEME_REGEX = /^https?:\/\//;
export { HTTPRequest };
/**
 * Extract the prefix and suffix of the url, where the prefix is the path before
 * the last file, and suffix is the search params after the last file.
 * ```
 * const url = 'http://tfhub.dev/model/1/tensorflowjs_model.pb?tfjs-format=file'
 * [prefix, suffix] = parseUrl(url)
 * // prefix = 'http://tfhub.dev/model/1/'
 * // suffix = '?tfjs-format=file'
 * ```
 * @param url the model url to be parsed.
 */
export function parseUrl(url) {
    const lastSlash = url.lastIndexOf('/');
    const lastSearchParam = url.lastIndexOf('?');
    const prefix = url.substring(0, lastSlash);
    const suffix = lastSearchParam > lastSlash ? url.substring(lastSearchParam) : '';
    return [prefix + '/', suffix];
}
export function isHTTPScheme(url) {
    return url.match(HTTPRequest.URL_SCHEME_REGEX) != null;
}
export const httpRouter = (url, loadOptions) => {
    if (typeof fetch === 'undefined' &&
        (loadOptions == null || loadOptions.fetchFunc == null)) {
        // `http` uses `fetch` or `node-fetch`, if one wants to use it in
        // an environment that is not the browser or node they have to setup a
        // global fetch polyfill.
        return null;
    }
    else {
        let isHTTP = true;
        if (Array.isArray(url)) {
            isHTTP = url.every(urlItem => isHTTPScheme(urlItem));
        }
        else {
            isHTTP = isHTTPScheme(url);
        }
        if (isHTTP) {
            return http(url, loadOptions);
        }
    }
    return null;
};
IORouterRegistry.registerSaveRouter(httpRouter);
IORouterRegistry.registerLoadRouter(httpRouter);
/**
 * Creates an IOHandler subtype that sends model artifacts to HTTP server.
 *
 * An HTTP request of the `multipart/form-data` mime type will be sent to the
 * `path` URL. The form data includes artifacts that represent the topology
 * and/or weights of the model. In the case of Keras-style `tf.Model`, two
 * blobs (files) exist in form-data:
 *   - A JSON file consisting of `modelTopology` and `weightsManifest`.
 *   - A binary weights file consisting of the concatenated weight values.
 * These files are in the same format as the one generated by
 * [tfjs_converter](https://js.tensorflow.org/tutorials/import-keras.html).
 *
 * The following code snippet exemplifies the client-side code that uses this
 * function:
 *
 * ```js
 * const model = tf.sequential();
 * model.add(
 *     tf.layers.dense({units: 1, inputShape: [100], activation: 'sigmoid'}));
 *
 * const saveResult = await model.save(tf.io.http(
 *     'http://model-server:5000/upload', {requestInit: {method: 'PUT'}}));
 * console.log(saveResult);
 * ```
 *
 * If the default `POST` method is to be used, without any custom parameters
 * such as headers, you can simply pass an HTTP or HTTPS URL to `model.save`:
 *
 * ```js
 * const saveResult = await model.save('http://model-server:5000/upload');
 * ```
 *
 * The following GitHub Gist
 * https://gist.github.com/dsmilkov/1b6046fd6132d7408d5257b0976f7864
 * implements a server based on [flask](https://github.com/pallets/flask) that
 * can receive the request. Upon receiving the model artifacts via the requst,
 * this particular server reconstitutes instances of [Keras
 * Models](https://keras.io/models/model/) in memory.
 *
 *
 * @param path A URL path to the model.
 *   Can be an absolute HTTP path (e.g.,
 *   'http://localhost:8000/model-upload)') or a relative path (e.g.,
 *   './model-upload').
 * @param requestInit Request configurations to be used when sending
 *    HTTP request to server using `fetch`. It can contain fields such as
 *    `method`, `credentials`, `headers`, `mode`, etc. See
 *    https://developer.mozilla.org/en-US/docs/Web/API/Request/Request
 *    for more information. `requestInit` must not have a body, because the
 * body will be set by TensorFlow.js. File blobs representing the model
 * topology (filename: 'model.json') and the weights of the model (filename:
 * 'model.weights.bin') will be appended to the body. If `requestInit` has a
 * `body`, an Error will be thrown.
 * @param loadOptions Optional configuration for the loading. It includes the
 *   following fields:
 *   - weightPathPrefix Optional, this specifies the path prefix for weight
 *     files, by default this is calculated from the path param.
 *   - fetchFunc Optional, custom `fetch` function. E.g., in Node.js,
 *     the `fetch` from node-fetch can be used here.
 *   - onProgress Optional, progress callback function, fired periodically
 *     before the load is completed.
 * @returns An instance of `IOHandler`.
 *
 * @doc {
 *   heading: 'Models',
 *   subheading: 'Loading',
 *   namespace: 'io',
 *   ignoreCI: true
 * }
 */
export function http(path, loadOptions) {
    return new HTTPRequest(path, loadOptions);
}
/**
 * Deprecated. Use `tf.io.http`.
 * @param path
 * @param loadOptions
 */
export function browserHTTPRequest(path, loadOptions) {
    return http(path, loadOptions);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/io/http.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n/**\n * IOHandler implementations based on HTTP requests in the web browser.\n *\n * Uses [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).\n */\n\nimport {env} from '../environment';\n\nimport {assert} from '../util';\nimport {getModelArtifactsForJSON, getModelArtifactsInfoForJSON, getModelJSONForModelArtifacts, getWeightSpecs} from './io_utils';\nimport {CompositeArrayBuffer} from './composite_array_buffer';\nimport {IORouter, IORouterRegistry} from './router_registry';\nimport {IOHandler, LoadOptions, ModelArtifacts, ModelJSON, SaveResult, WeightData, WeightsManifestConfig, WeightsManifestEntry} from './types';\nimport {loadWeightsAsArrayBuffer, streamWeights} from './weights_loader';\n\nconst OCTET_STREAM_MIME_TYPE = 'application/octet-stream';\nconst JSON_TYPE = 'application/json';\nexport class HTTPRequest implements IOHandler {\n  protected readonly path: string;\n  protected readonly requestInit: RequestInit;\n\n  private readonly fetch: typeof fetch;\n  private readonly weightUrlConverter: (weightName: string) => Promise<string>;\n\n  readonly DEFAULT_METHOD = 'POST';\n\n  static readonly URL_SCHEME_REGEX = /^https?:\\/\\//;\n\n  private readonly weightPathPrefix: string;\n  private readonly loadOptions: LoadOptions;\n\n  constructor(path: string, loadOptions?: LoadOptions) {\n    if (loadOptions == null) {\n      loadOptions = {};\n    }\n    this.weightPathPrefix = loadOptions.weightPathPrefix;\n    this.weightUrlConverter = loadOptions.weightUrlConverter;\n\n    if (loadOptions.fetchFunc != null) {\n      assert(\n          typeof loadOptions.fetchFunc === 'function',\n          () => 'Must pass a function that matches the signature of ' +\n              '`fetch` (see ' +\n              'https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)');\n      this.fetch = loadOptions.fetchFunc;\n    } else {\n      this.fetch = env().platform.fetch;\n    }\n\n    assert(\n        path != null && path.length > 0,\n        () => 'URL path for http must not be null, undefined or ' +\n            'empty.');\n\n    if (Array.isArray(path)) {\n      assert(\n          path.length === 2,\n          () => 'URL paths for http must have a length of 2, ' +\n              `(actual length is ${path.length}).`);\n    }\n    this.path = path;\n\n    if (loadOptions.requestInit != null &&\n        loadOptions.requestInit.body != null) {\n      throw new Error(\n          'requestInit is expected to have no pre-existing body, but has one.');\n    }\n    this.requestInit = loadOptions.requestInit || {};\n    this.loadOptions = loadOptions;\n  }\n\n  async save(modelArtifacts: ModelArtifacts): Promise<SaveResult> {\n    if (modelArtifacts.modelTopology instanceof ArrayBuffer) {\n      throw new Error(\n          'BrowserHTTPRequest.save() does not support saving model topology ' +\n          'in binary formats yet.');\n    }\n\n    const init = Object.assign({method: this.DEFAULT_METHOD}, this.requestInit);\n    init.body = new FormData();\n\n    const weightsManifest: WeightsManifestConfig = [{\n      paths: ['./model.weights.bin'],\n      weights: modelArtifacts.weightSpecs,\n    }];\n    const modelTopologyAndWeightManifest: ModelJSON =\n        getModelJSONForModelArtifacts(modelArtifacts, weightsManifest);\n\n    init.body.append(\n        'model.json',\n        new Blob(\n            [JSON.stringify(modelTopologyAndWeightManifest)],\n            {type: JSON_TYPE}),\n        'model.json');\n\n    if (modelArtifacts.weightData != null) {\n      // TODO(mattsoulanille): Support saving models over 2GB that exceed\n      // Chrome's ArrayBuffer size limit.\n      const weightBuffer = CompositeArrayBuffer.join(modelArtifacts.weightData);\n\n      init.body.append(\n          'model.weights.bin',\n          new Blob([weightBuffer], {type: OCTET_STREAM_MIME_TYPE}),\n          'model.weights.bin');\n    }\n\n    const response = await this.fetch(this.path, init);\n\n    if (response.ok) {\n      return {\n        modelArtifactsInfo: getModelArtifactsInfoForJSON(modelArtifacts),\n        responses: [response],\n      };\n    } else {\n      throw new Error(\n          `BrowserHTTPRequest.save() failed due to HTTP response status ` +\n          `${response.status}.`);\n    }\n  }\n\n  private async loadModelJSON(): Promise<ModelJSON> {\n    const modelConfigRequest = await this.fetch(this.path, this.requestInit);\n\n    if (!modelConfigRequest.ok) {\n      throw new Error(\n          `Request to ${this.path} failed with status code ` +\n          `${modelConfigRequest.status}. Please verify this URL points to ` +\n          `the model JSON of the model to load.`);\n    }\n    let modelJSON: ModelJSON;\n    try {\n      modelJSON = await modelConfigRequest.json();\n    } catch (e) {\n      let message = `Failed to parse model JSON of response from ${this.path}.`;\n      // TODO(nsthorat): Remove this after some time when we're comfortable that\n      // .pb files are mostly gone.\n      if (this.path.endsWith('.pb')) {\n        message += ' Your path contains a .pb file extension. ' +\n            'Support for .pb models have been removed in TensorFlow.js 1.0 ' +\n            'in favor of .json models. You can re-convert your Python ' +\n            'TensorFlow model using the TensorFlow.js 1.0 conversion scripts ' +\n            'or you can convert your.pb models with the \\'pb2json\\'' +\n            'NPM script in the tensorflow/tfjs-converter repository.';\n      } else {\n        message += ' Please make sure the server is serving valid ' +\n            'JSON for this request.';\n      }\n      throw new Error(message);\n    }\n\n    // We do not allow both modelTopology and weightsManifest to be missing.\n    const modelTopology = modelJSON.modelTopology;\n    const weightsManifest = modelJSON.weightsManifest;\n    if (modelTopology == null && weightsManifest == null) {\n      throw new Error(\n          `The JSON from HTTP path ${this.path} contains neither model ` +\n          `topology or manifest for weights.`);\n    }\n\n    return modelJSON;\n  }\n\n  /**\n   * Load model artifacts via HTTP request(s).\n   *\n   * See the documentation to `tf.io.http` for details on the saved\n   * artifacts.\n   *\n   * @returns The loaded model artifacts (if loading succeeds).\n   */\n  async load(): Promise<ModelArtifacts> {\n    if (this.loadOptions.streamWeights) {\n      return this.loadStream();\n    }\n    const modelJSON = await this.loadModelJSON();\n    return getModelArtifactsForJSON(\n        modelJSON, (weightsManifest) => this.loadWeights(weightsManifest));\n  }\n\n  private async loadStream(): Promise<ModelArtifacts> {\n    const modelJSON = await this.loadModelJSON();\n    const fetchURLs = await this.getWeightUrls(modelJSON.weightsManifest);\n    const weightSpecs = getWeightSpecs(modelJSON.weightsManifest);\n    const stream = () => streamWeights(fetchURLs, this.loadOptions);\n\n    return {\n      ...modelJSON,\n      weightSpecs,\n      getWeightStream: stream,\n    };\n  }\n\n  private async getWeightUrls(weightsManifest: WeightsManifestConfig):\n    Promise<string[]> {\n    const weightPath = Array.isArray(this.path) ? this.path[1] : this.path;\n    const [prefix, suffix] = parseUrl(weightPath);\n    const pathPrefix = this.weightPathPrefix || prefix;\n\n    const fetchURLs: string[] = [];\n    const urlPromises: Array<Promise<string>> = [];\n    for (const weightsGroup of weightsManifest) {\n      for (const path of weightsGroup.paths) {\n        if (this.weightUrlConverter != null) {\n          urlPromises.push(this.weightUrlConverter(path));\n        } else {\n          fetchURLs.push(pathPrefix + path + suffix);\n        }\n      }\n    }\n\n    if (this.weightUrlConverter) {\n      fetchURLs.push(...await Promise.all(urlPromises));\n    }\n    return fetchURLs;\n  }\n\n  private async loadWeights(weightsManifest: WeightsManifestConfig):\n    Promise<[WeightsManifestEntry[], WeightData]> {\n    const fetchURLs = await this.getWeightUrls(weightsManifest);\n    const weightSpecs = getWeightSpecs(weightsManifest);\n\n    const buffers = await loadWeightsAsArrayBuffer(fetchURLs, this.loadOptions);\n    return [weightSpecs, buffers];\n  }\n}\n\n/**\n * Extract the prefix and suffix of the url, where the prefix is the path before\n * the last file, and suffix is the search params after the last file.\n * ```\n * const url = 'http://tfhub.dev/model/1/tensorflowjs_model.pb?tfjs-format=file'\n * [prefix, suffix] = parseUrl(url)\n * // prefix = 'http://tfhub.dev/model/1/'\n * // suffix = '?tfjs-format=file'\n * ```\n * @param url the model url to be parsed.\n */\nexport function parseUrl(url: string): [string, string] {\n  const lastSlash = url.lastIndexOf('/');\n  const lastSearchParam = url.lastIndexOf('?');\n  const prefix = url.substring(0, lastSlash);\n  const suffix =\n      lastSearchParam > lastSlash ? url.substring(lastSearchParam) : '';\n  return [prefix + '/', suffix];\n}\n\nexport function isHTTPScheme(url: string): boolean {\n  return url.match(HTTPRequest.URL_SCHEME_REGEX) != null;\n}\n\nexport const httpRouter: IORouter =\n    (url: string, loadOptions?: LoadOptions) => {\n      if (typeof fetch === 'undefined' &&\n          (loadOptions == null || loadOptions.fetchFunc == null)) {\n        // `http` uses `fetch` or `node-fetch`, if one wants to use it in\n        // an environment that is not the browser or node they have to setup a\n        // global fetch polyfill.\n        return null;\n      } else {\n        let isHTTP = true;\n        if (Array.isArray(url)) {\n          isHTTP = url.every(urlItem => isHTTPScheme(urlItem));\n        } else {\n          isHTTP = isHTTPScheme(url);\n        }\n        if (isHTTP) {\n          return http(url, loadOptions);\n        }\n      }\n      return null;\n    };\nIORouterRegistry.registerSaveRouter(httpRouter);\nIORouterRegistry.registerLoadRouter(httpRouter);\n\n/**\n * Creates an IOHandler subtype that sends model artifacts to HTTP server.\n *\n * An HTTP request of the `multipart/form-data` mime type will be sent to the\n * `path` URL. The form data includes artifacts that represent the topology\n * and/or weights of the model. In the case of Keras-style `tf.Model`, two\n * blobs (files) exist in form-data:\n *   - A JSON file consisting of `modelTopology` and `weightsManifest`.\n *   - A binary weights file consisting of the concatenated weight values.\n * These files are in the same format as the one generated by\n * [tfjs_converter](https://js.tensorflow.org/tutorials/import-keras.html).\n *\n * The following code snippet exemplifies the client-side code that uses this\n * function:\n *\n * ```js\n * const model = tf.sequential();\n * model.add(\n *     tf.layers.dense({units: 1, inputShape: [100], activation: 'sigmoid'}));\n *\n * const saveResult = await model.save(tf.io.http(\n *     'http://model-server:5000/upload', {requestInit: {method: 'PUT'}}));\n * console.log(saveResult);\n * ```\n *\n * If the default `POST` method is to be used, without any custom parameters\n * such as headers, you can simply pass an HTTP or HTTPS URL to `model.save`:\n *\n * ```js\n * const saveResult = await model.save('http://model-server:5000/upload');\n * ```\n *\n * The following GitHub Gist\n * https://gist.github.com/dsmilkov/1b6046fd6132d7408d5257b0976f7864\n * implements a server based on [flask](https://github.com/pallets/flask) that\n * can receive the request. Upon receiving the model artifacts via the requst,\n * this particular server reconstitutes instances of [Keras\n * Models](https://keras.io/models/model/) in memory.\n *\n *\n * @param path A URL path to the model.\n *   Can be an absolute HTTP path (e.g.,\n *   'http://localhost:8000/model-upload)') or a relative path (e.g.,\n *   './model-upload').\n * @param requestInit Request configurations to be used when sending\n *    HTTP request to server using `fetch`. It can contain fields such as\n *    `method`, `credentials`, `headers`, `mode`, etc. See\n *    https://developer.mozilla.org/en-US/docs/Web/API/Request/Request\n *    for more information. `requestInit` must not have a body, because the\n * body will be set by TensorFlow.js. File blobs representing the model\n * topology (filename: 'model.json') and the weights of the model (filename:\n * 'model.weights.bin') will be appended to the body. If `requestInit` has a\n * `body`, an Error will be thrown.\n * @param loadOptions Optional configuration for the loading. It includes the\n *   following fields:\n *   - weightPathPrefix Optional, this specifies the path prefix for weight\n *     files, by default this is calculated from the path param.\n *   - fetchFunc Optional, custom `fetch` function. E.g., in Node.js,\n *     the `fetch` from node-fetch can be used here.\n *   - onProgress Optional, progress callback function, fired periodically\n *     before the load is completed.\n * @returns An instance of `IOHandler`.\n *\n * @doc {\n *   heading: 'Models',\n *   subheading: 'Loading',\n *   namespace: 'io',\n *   ignoreCI: true\n * }\n */\nexport function http(path: string, loadOptions?: LoadOptions): IOHandler {\n  return new HTTPRequest(path, loadOptions);\n}\n\n/**\n * Deprecated. Use `tf.io.http`.\n * @param path\n * @param loadOptions\n */\nexport function browserHTTPRequest(\n    path: string, loadOptions?: LoadOptions): IOHandler {\n  return http(path, loadOptions);\n}\n"]}