/**
 * @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.
 * =============================================================================
 */
/**
 * Classes and functions for model management across multiple storage mediums.
 *
 * Supported client actions:
 * - Listing models on all registered storage mediums.
 * - Remove model by URL from any registered storage mediums, by using URL
 *   string.
 * - Moving or copying model from one path to another in the same medium or from
 *   one medium to another, by using URL strings.
 */
import { assert } from '../util';
import { IORouterRegistry } from './router_registry';
const URL_SCHEME_SUFFIX = '://';
export class ModelStoreManagerRegistry {
    constructor() {
        this.managers = {};
    }
    static getInstance() {
        if (ModelStoreManagerRegistry.instance == null) {
            ModelStoreManagerRegistry.instance = new ModelStoreManagerRegistry();
        }
        return ModelStoreManagerRegistry.instance;
    }
    /**
     * Register a save-handler router.
     *
     * @param saveRouter A function that maps a URL-like string onto an instance
     * of `IOHandler` with the `save` method defined or `null`.
     */
    static registerManager(scheme, manager) {
        assert(scheme != null, () => 'scheme must not be undefined or null.');
        if (scheme.endsWith(URL_SCHEME_SUFFIX)) {
            scheme = scheme.slice(0, scheme.indexOf(URL_SCHEME_SUFFIX));
        }
        assert(scheme.length > 0, () => 'scheme must not be an empty string.');
        const registry = ModelStoreManagerRegistry.getInstance();
        assert(registry.managers[scheme] == null, () => `A model store manager is already registered for scheme '${scheme}'.`);
        registry.managers[scheme] = manager;
    }
    static getManager(scheme) {
        const manager = ModelStoreManagerRegistry.getInstance().managers[scheme];
        if (manager == null) {
            throw new Error(`Cannot find model manager for scheme '${scheme}'`);
        }
        return manager;
    }
    static getSchemes() {
        return Object.keys(ModelStoreManagerRegistry.getInstance().managers);
    }
}
/**
 * Helper method for parsing a URL string into a scheme and a path.
 *
 * @param url E.g., 'localstorage://my-model'
 * @returns A dictionary with two fields: scheme and path.
 *   Scheme: e.g., 'localstorage' in the example above.
 *   Path: e.g., 'my-model' in the example above.
 */
function parseURL(url) {
    if (url.indexOf(URL_SCHEME_SUFFIX) === -1) {
        throw new Error(`The url string provided does not contain a scheme. ` +
            `Supported schemes are: ` +
            `${ModelStoreManagerRegistry.getSchemes().join(',')}`);
    }
    return {
        scheme: url.split(URL_SCHEME_SUFFIX)[0],
        path: url.split(URL_SCHEME_SUFFIX)[1],
    };
}
async function cloneModelInternal(sourceURL, destURL, deleteSource = false) {
    assert(sourceURL !== destURL, () => `Old path and new path are the same: '${sourceURL}'`);
    const loadHandlers = IORouterRegistry.getLoadHandlers(sourceURL);
    assert(loadHandlers.length > 0, () => `Copying failed because no load handler is found for source URL ${sourceURL}.`);
    assert(loadHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) ` +
        `load handlers for source URL ${sourceURL}.`);
    const loadHandler = loadHandlers[0];
    const saveHandlers = IORouterRegistry.getSaveHandlers(destURL);
    assert(saveHandlers.length > 0, () => `Copying failed because no save handler is found for destination ` +
        `URL ${destURL}.`);
    assert(saveHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) ` +
        `save handlers for destination URL ${destURL}.`);
    const saveHandler = saveHandlers[0];
    const sourceScheme = parseURL(sourceURL).scheme;
    const sourcePath = parseURL(sourceURL).path;
    const sameMedium = sourceScheme === parseURL(sourceURL).scheme;
    const modelArtifacts = await loadHandler.load();
    // If moving within the same storage medium, remove the old model as soon as
    // the loading is done. Without doing this, it is possible that the combined
    // size of the two models will cause the cloning to fail.
    if (deleteSource && sameMedium) {
        await ModelStoreManagerRegistry.getManager(sourceScheme)
            .removeModel(sourcePath);
    }
    const saveResult = await saveHandler.save(modelArtifacts);
    // If moving between mediums, the deletion is done after the save succeeds.
    // This guards against the case in which saving to the destination medium
    // fails.
    if (deleteSource && !sameMedium) {
        await ModelStoreManagerRegistry.getManager(sourceScheme)
            .removeModel(sourcePath);
    }
    return saveResult.modelArtifactsInfo;
}
/**
 * List all models stored in registered storage mediums.
 *
 * For a web browser environment, the registered mediums are Local Storage and
 * IndexedDB.
 *
 * ```js
 * // First create and save a model.
 * const model = tf.sequential();
 * model.add(tf.layers.dense(
 *     {units: 1, inputShape: [10], activation: 'sigmoid'}));
 * await model.save('localstorage://demo/management/model1');
 *
 * // Then list existing models.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Delete the model.
 * await tf.io.removeModel('localstorage://demo/management/model1');
 *
 * // List models again.
 * console.log(JSON.stringify(await tf.io.listModels()));
 * ```
 *
 * @returns A `Promise` of a dictionary mapping URLs of existing models to
 * their model artifacts info. URLs include medium-specific schemes, e.g.,
 *   'indexeddb://my/model/1'. Model artifacts info include type of the
 * model's topology, byte sizes of the topology, weights, etc.
 *
 * @doc {
 *   heading: 'Models',
 *   subheading: 'Management',
 *   namespace: 'io',
 *   ignoreCI: true
 * }
 */
async function listModels() {
    const schemes = ModelStoreManagerRegistry.getSchemes();
    const out = {};
    for (const scheme of schemes) {
        const schemeOut = await ModelStoreManagerRegistry.getManager(scheme).listModels();
        for (const path in schemeOut) {
            const url = scheme + URL_SCHEME_SUFFIX + path;
            out[url] = schemeOut[path];
        }
    }
    return out;
}
/**
 * Remove a model specified by URL from a registered storage medium.
 *
 * ```js
 * // First create and save a model.
 * const model = tf.sequential();
 * model.add(tf.layers.dense(
 *     {units: 1, inputShape: [10], activation: 'sigmoid'}));
 * await model.save('localstorage://demo/management/model1');
 *
 * // Then list existing models.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Delete the model.
 * await tf.io.removeModel('localstorage://demo/management/model1');
 *
 * // List models again.
 * console.log(JSON.stringify(await tf.io.listModels()));
 * ```
 *
 * @param url A URL to a stored model, with a scheme prefix, e.g.,
 *   'localstorage://my-model-1', 'indexeddb://my/model/2'.
 * @returns ModelArtifactsInfo of the deleted model (if and only if deletion
 *   is successful).
 * @throws Error if deletion fails, e.g., if no model exists at `path`.
 *
 * @doc {
 *   heading: 'Models',
 *   subheading: 'Management',
 *   namespace: 'io',
 *   ignoreCI: true
 * }
 */
async function removeModel(url) {
    const schemeAndPath = parseURL(url);
    const manager = ModelStoreManagerRegistry.getManager(schemeAndPath.scheme);
    return manager.removeModel(schemeAndPath.path);
}
/**
 * Copy a model from one URL to another.
 *
 * This function supports:
 *
 * 1. Copying within a storage medium, e.g.,
 *    `tf.io.copyModel('localstorage://model-1', 'localstorage://model-2')`
 * 2. Copying between two storage mediums, e.g.,
 *    `tf.io.copyModel('localstorage://model-1', 'indexeddb://model-1')`
 *
 * ```js
 * // First create and save a model.
 * const model = tf.sequential();
 * model.add(tf.layers.dense(
 *     {units: 1, inputShape: [10], activation: 'sigmoid'}));
 * await model.save('localstorage://demo/management/model1');
 *
 * // Then list existing models.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Copy the model, from Local Storage to IndexedDB.
 * await tf.io.copyModel(
 *     'localstorage://demo/management/model1',
 *     'indexeddb://demo/management/model1');
 *
 * // List models again.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Remove both models.
 * await tf.io.removeModel('localstorage://demo/management/model1');
 * await tf.io.removeModel('indexeddb://demo/management/model1');
 * ```
 *
 * @param sourceURL Source URL of copying.
 * @param destURL Destination URL of copying.
 * @returns ModelArtifactsInfo of the copied model (if and only if copying
 *   is successful).
 * @throws Error if copying fails, e.g., if no model exists at `sourceURL`, or
 *   if `oldPath` and `newPath` are identical.
 *
 * @doc {
 *   heading: 'Models',
 *   subheading: 'Management',
 *   namespace: 'io',
 *   ignoreCI: true
 * }
 */
async function copyModel(sourceURL, destURL) {
    const deleteSource = false;
    return cloneModelInternal(sourceURL, destURL, deleteSource);
}
/**
 * Move a model from one URL to another.
 *
 * This function supports:
 *
 * 1. Moving within a storage medium, e.g.,
 *    `tf.io.moveModel('localstorage://model-1', 'localstorage://model-2')`
 * 2. Moving between two storage mediums, e.g.,
 *    `tf.io.moveModel('localstorage://model-1', 'indexeddb://model-1')`
 *
 * ```js
 * // First create and save a model.
 * const model = tf.sequential();
 * model.add(tf.layers.dense(
 *     {units: 1, inputShape: [10], activation: 'sigmoid'}));
 * await model.save('localstorage://demo/management/model1');
 *
 * // Then list existing models.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Move the model, from Local Storage to IndexedDB.
 * await tf.io.moveModel(
 *     'localstorage://demo/management/model1',
 *     'indexeddb://demo/management/model1');
 *
 * // List models again.
 * console.log(JSON.stringify(await tf.io.listModels()));
 *
 * // Remove the moved model.
 * await tf.io.removeModel('indexeddb://demo/management/model1');
 * ```
 *
 * @param sourceURL Source URL of moving.
 * @param destURL Destination URL of moving.
 * @returns ModelArtifactsInfo of the copied model (if and only if copying
 *   is successful).
 * @throws Error if moving fails, e.g., if no model exists at `sourceURL`, or
 *   if `oldPath` and `newPath` are identical.
 *
 * @doc {
 *   heading: 'Models',
 *   subheading: 'Management',
 *   namespace: 'io',
 *   ignoreCI: true
 * }
 */
async function moveModel(sourceURL, destURL) {
    const deleteSource = true;
    return cloneModelInternal(sourceURL, destURL, deleteSource);
}
export { moveModel, copyModel, removeModel, listModels };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model_management.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/io/model_management.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 * Classes and functions for model management across multiple storage mediums.\n *\n * Supported client actions:\n * - Listing models on all registered storage mediums.\n * - Remove model by URL from any registered storage mediums, by using URL\n *   string.\n * - Moving or copying model from one path to another in the same medium or from\n *   one medium to another, by using URL strings.\n */\n\nimport {assert} from '../util';\n\nimport {IORouterRegistry} from './router_registry';\nimport {ModelArtifactsInfo, ModelStoreManager} from './types';\n\nconst URL_SCHEME_SUFFIX = '://';\n\nexport class ModelStoreManagerRegistry {\n  // Singleton instance.\n  private static instance: ModelStoreManagerRegistry;\n\n  private managers: {[scheme: string]: ModelStoreManager};\n\n  private constructor() {\n    this.managers = {};\n  }\n\n  private static getInstance(): ModelStoreManagerRegistry {\n    if (ModelStoreManagerRegistry.instance == null) {\n      ModelStoreManagerRegistry.instance = new ModelStoreManagerRegistry();\n    }\n    return ModelStoreManagerRegistry.instance;\n  }\n\n  /**\n   * Register a save-handler router.\n   *\n   * @param saveRouter A function that maps a URL-like string onto an instance\n   * of `IOHandler` with the `save` method defined or `null`.\n   */\n  static registerManager(scheme: string, manager: ModelStoreManager) {\n    assert(scheme != null, () => 'scheme must not be undefined or null.');\n    if (scheme.endsWith(URL_SCHEME_SUFFIX)) {\n      scheme = scheme.slice(0, scheme.indexOf(URL_SCHEME_SUFFIX));\n    }\n    assert(scheme.length > 0, () => 'scheme must not be an empty string.');\n    const registry = ModelStoreManagerRegistry.getInstance();\n    assert(\n        registry.managers[scheme] == null,\n        () => `A model store manager is already registered for scheme '${\n            scheme}'.`);\n    registry.managers[scheme] = manager;\n  }\n\n  static getManager(scheme: string): ModelStoreManager {\n    const manager = ModelStoreManagerRegistry.getInstance().managers[scheme];\n    if (manager == null) {\n      throw new Error(`Cannot find model manager for scheme '${scheme}'`);\n    }\n    return manager;\n  }\n\n  static getSchemes(): string[] {\n    return Object.keys(ModelStoreManagerRegistry.getInstance().managers);\n  }\n}\n\n/**\n * Helper method for parsing a URL string into a scheme and a path.\n *\n * @param url E.g., 'localstorage://my-model'\n * @returns A dictionary with two fields: scheme and path.\n *   Scheme: e.g., 'localstorage' in the example above.\n *   Path: e.g., 'my-model' in the example above.\n */\nfunction parseURL(url: string): {scheme: string, path: string} {\n  if (url.indexOf(URL_SCHEME_SUFFIX) === -1) {\n    throw new Error(\n        `The url string provided does not contain a scheme. ` +\n        `Supported schemes are: ` +\n        `${ModelStoreManagerRegistry.getSchemes().join(',')}`);\n  }\n  return {\n    scheme: url.split(URL_SCHEME_SUFFIX)[0],\n    path: url.split(URL_SCHEME_SUFFIX)[1],\n  };\n}\n\nasync function cloneModelInternal(\n    sourceURL: string, destURL: string,\n    deleteSource = false): Promise<ModelArtifactsInfo> {\n  assert(\n      sourceURL !== destURL,\n      () => `Old path and new path are the same: '${sourceURL}'`);\n\n  const loadHandlers = IORouterRegistry.getLoadHandlers(sourceURL);\n  assert(\n      loadHandlers.length > 0,\n      () => `Copying failed because no load handler is found for source URL ${\n          sourceURL}.`);\n  assert(\n      loadHandlers.length < 2,\n      () => `Copying failed because more than one (${loadHandlers.length}) ` +\n          `load handlers for source URL ${sourceURL}.`);\n  const loadHandler = loadHandlers[0];\n\n  const saveHandlers = IORouterRegistry.getSaveHandlers(destURL);\n  assert(\n      saveHandlers.length > 0,\n      () => `Copying failed because no save handler is found for destination ` +\n          `URL ${destURL}.`);\n  assert(\n      saveHandlers.length < 2,\n      () => `Copying failed because more than one (${loadHandlers.length}) ` +\n          `save handlers for destination URL ${destURL}.`);\n  const saveHandler = saveHandlers[0];\n\n  const sourceScheme = parseURL(sourceURL).scheme;\n  const sourcePath = parseURL(sourceURL).path;\n  const sameMedium = sourceScheme === parseURL(sourceURL).scheme;\n\n  const modelArtifacts = await loadHandler.load();\n\n  // If moving within the same storage medium, remove the old model as soon as\n  // the loading is done. Without doing this, it is possible that the combined\n  // size of the two models will cause the cloning to fail.\n  if (deleteSource && sameMedium) {\n    await ModelStoreManagerRegistry.getManager(sourceScheme)\n        .removeModel(sourcePath);\n  }\n\n  const saveResult = await saveHandler.save(modelArtifacts);\n\n  // If moving between mediums, the deletion is done after the save succeeds.\n  // This guards against the case in which saving to the destination medium\n  // fails.\n  if (deleteSource && !sameMedium) {\n    await ModelStoreManagerRegistry.getManager(sourceScheme)\n        .removeModel(sourcePath);\n  }\n\n  return saveResult.modelArtifactsInfo;\n}\n\n/**\n * List all models stored in registered storage mediums.\n *\n * For a web browser environment, the registered mediums are Local Storage and\n * IndexedDB.\n *\n * ```js\n * // First create and save a model.\n * const model = tf.sequential();\n * model.add(tf.layers.dense(\n *     {units: 1, inputShape: [10], activation: 'sigmoid'}));\n * await model.save('localstorage://demo/management/model1');\n *\n * // Then list existing models.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Delete the model.\n * await tf.io.removeModel('localstorage://demo/management/model1');\n *\n * // List models again.\n * console.log(JSON.stringify(await tf.io.listModels()));\n * ```\n *\n * @returns A `Promise` of a dictionary mapping URLs of existing models to\n * their model artifacts info. URLs include medium-specific schemes, e.g.,\n *   'indexeddb://my/model/1'. Model artifacts info include type of the\n * model's topology, byte sizes of the topology, weights, etc.\n *\n * @doc {\n *   heading: 'Models',\n *   subheading: 'Management',\n *   namespace: 'io',\n *   ignoreCI: true\n * }\n */\nasync function listModels(): Promise<{[url: string]: ModelArtifactsInfo}> {\n  const schemes = ModelStoreManagerRegistry.getSchemes();\n  const out: {[url: string]: ModelArtifactsInfo} = {};\n  for (const scheme of schemes) {\n    const schemeOut =\n        await ModelStoreManagerRegistry.getManager(scheme).listModels();\n    for (const path in schemeOut) {\n      const url = scheme + URL_SCHEME_SUFFIX + path;\n      out[url] = schemeOut[path];\n    }\n  }\n  return out;\n}\n\n/**\n * Remove a model specified by URL from a registered storage medium.\n *\n * ```js\n * // First create and save a model.\n * const model = tf.sequential();\n * model.add(tf.layers.dense(\n *     {units: 1, inputShape: [10], activation: 'sigmoid'}));\n * await model.save('localstorage://demo/management/model1');\n *\n * // Then list existing models.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Delete the model.\n * await tf.io.removeModel('localstorage://demo/management/model1');\n *\n * // List models again.\n * console.log(JSON.stringify(await tf.io.listModels()));\n * ```\n *\n * @param url A URL to a stored model, with a scheme prefix, e.g.,\n *   'localstorage://my-model-1', 'indexeddb://my/model/2'.\n * @returns ModelArtifactsInfo of the deleted model (if and only if deletion\n *   is successful).\n * @throws Error if deletion fails, e.g., if no model exists at `path`.\n *\n * @doc {\n *   heading: 'Models',\n *   subheading: 'Management',\n *   namespace: 'io',\n *   ignoreCI: true\n * }\n */\nasync function removeModel(url: string): Promise<ModelArtifactsInfo> {\n  const schemeAndPath = parseURL(url);\n  const manager = ModelStoreManagerRegistry.getManager(schemeAndPath.scheme);\n  return manager.removeModel(schemeAndPath.path);\n}\n\n/**\n * Copy a model from one URL to another.\n *\n * This function supports:\n *\n * 1. Copying within a storage medium, e.g.,\n *    `tf.io.copyModel('localstorage://model-1', 'localstorage://model-2')`\n * 2. Copying between two storage mediums, e.g.,\n *    `tf.io.copyModel('localstorage://model-1', 'indexeddb://model-1')`\n *\n * ```js\n * // First create and save a model.\n * const model = tf.sequential();\n * model.add(tf.layers.dense(\n *     {units: 1, inputShape: [10], activation: 'sigmoid'}));\n * await model.save('localstorage://demo/management/model1');\n *\n * // Then list existing models.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Copy the model, from Local Storage to IndexedDB.\n * await tf.io.copyModel(\n *     'localstorage://demo/management/model1',\n *     'indexeddb://demo/management/model1');\n *\n * // List models again.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Remove both models.\n * await tf.io.removeModel('localstorage://demo/management/model1');\n * await tf.io.removeModel('indexeddb://demo/management/model1');\n * ```\n *\n * @param sourceURL Source URL of copying.\n * @param destURL Destination URL of copying.\n * @returns ModelArtifactsInfo of the copied model (if and only if copying\n *   is successful).\n * @throws Error if copying fails, e.g., if no model exists at `sourceURL`, or\n *   if `oldPath` and `newPath` are identical.\n *\n * @doc {\n *   heading: 'Models',\n *   subheading: 'Management',\n *   namespace: 'io',\n *   ignoreCI: true\n * }\n */\nasync function copyModel(\n    sourceURL: string, destURL: string): Promise<ModelArtifactsInfo> {\n  const deleteSource = false;\n  return cloneModelInternal(sourceURL, destURL, deleteSource);\n}\n\n/**\n * Move a model from one URL to another.\n *\n * This function supports:\n *\n * 1. Moving within a storage medium, e.g.,\n *    `tf.io.moveModel('localstorage://model-1', 'localstorage://model-2')`\n * 2. Moving between two storage mediums, e.g.,\n *    `tf.io.moveModel('localstorage://model-1', 'indexeddb://model-1')`\n *\n * ```js\n * // First create and save a model.\n * const model = tf.sequential();\n * model.add(tf.layers.dense(\n *     {units: 1, inputShape: [10], activation: 'sigmoid'}));\n * await model.save('localstorage://demo/management/model1');\n *\n * // Then list existing models.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Move the model, from Local Storage to IndexedDB.\n * await tf.io.moveModel(\n *     'localstorage://demo/management/model1',\n *     'indexeddb://demo/management/model1');\n *\n * // List models again.\n * console.log(JSON.stringify(await tf.io.listModels()));\n *\n * // Remove the moved model.\n * await tf.io.removeModel('indexeddb://demo/management/model1');\n * ```\n *\n * @param sourceURL Source URL of moving.\n * @param destURL Destination URL of moving.\n * @returns ModelArtifactsInfo of the copied model (if and only if copying\n *   is successful).\n * @throws Error if moving fails, e.g., if no model exists at `sourceURL`, or\n *   if `oldPath` and `newPath` are identical.\n *\n * @doc {\n *   heading: 'Models',\n *   subheading: 'Management',\n *   namespace: 'io',\n *   ignoreCI: true\n * }\n */\nasync function moveModel(\n    sourceURL: string, destURL: string): Promise<ModelArtifactsInfo> {\n  const deleteSource = true;\n  return cloneModelInternal(sourceURL, destURL, deleteSource);\n}\n\nexport {moveModel, copyModel, removeModel, listModels};\n"]}