@iiasa/ixmp4-ts 0.1.1 → 0.1.2

package/dist/cjs/data/scenario.js

@@ -14,22 +14,22 @@ const base_1 = require("./base");
 const docs_1 = require("./docs");
 class ScenarioRepository extends base_1.BaseRepository {
     constructor(client) {
-        super(client, ScenarioRepository.prefix, ScenarioRepository.enumerationMethod);
+        super(client);
         this.docs = new docs_1.DocsRepository(client, 'docs/scenarios/');
     }
-    list(f = {}) {
+    list(filter = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield this._list(f));
+            return (yield this._list({ filter }));
         });
     }
-    tabulate(f = {}) {
+    tabulate(filter = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this._tabulate(f);
+            return yield this._tabulate({ filter });
         });
     }
     create(name) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield this._post({ name: name }));
+            return (yield this._post({ name }));
         });
     }
     get(name) {
@@ -40,4 +40,3 @@ class ScenarioRepository extends base_1.BaseRepository {
 }
 exports.ScenarioRepository = ScenarioRepository;
 ScenarioRepository.prefix = 'scenarios/';
-ScenarioRepository.enumerationMethod = 'PATCH';

package/dist/cjs/data/unit.js

@@ -14,7 +14,7 @@ const base_1 = require("./base");
 const docs_1 = require("./docs");
 class UnitRepository extends base_1.BaseRepository {
     constructor(client) {
-        super(client, UnitRepository.prefix, UnitRepository.enumerationMethod);
+        super(client);
         this.docs = new docs_1.DocsRepository(client, 'docs/units/');
     }
     create(name) {
@@ -32,17 +32,16 @@ class UnitRepository extends base_1.BaseRepository {
             return (yield this._get({ name }));
         });
     }
-    list(f = {}) {
+    list(filter = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield this._list(f));
+            return (yield this._list({ filter }));
         });
     }
-    tabulate(f = {}) {
+    tabulate(filter = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this._tabulate(f);
+            return yield this._tabulate({ filter });
         });
     }
 }
 exports.UnitRepository = UnitRepository;
 UnitRepository.prefix = 'units/';
-UnitRepository.enumerationMethod = 'PATCH';

package/dist/esm/core/iamc/data.js

@@ -1,25 +1,25 @@
 import * as dfd from 'danfojs';
 import { BaseFacade } from '../base';
-import { IamcRepository } from './repository';
 import { dfToDimensionless, substitudeType } from '../utils';
+import { VariableRepository } from './variable';
 /**
- * Represents a IAMC format data.
+ * Represents IAMC format data for a specific Run.
  */
-class IamcData extends BaseFacade {
+class RunIamcData extends BaseFacade {
     /**
      * The run associated with the IAMC data.
      */
     run;
     repository;
     /**
-     * Constructs a new instance of the IamcData class.
+     * Constructs a new instance of the RunIamcData class.
      * @param backend The backend instance.
      * @param run The run associated with the IAMC data.
      */
     constructor(backend, run) {
         super(backend);
         this.run = run;
-        this.repository = new IamcRepository(this.backend);
+        this.repository = new PlatformIamcData(this.backend);
     }
     /**
      * Adds timeseries data in IAMC format.
@@ -69,7 +69,7 @@ class IamcData extends BaseFacade {
             }
         }
         return await this.repository.tabulate({
-            run: { id: this.run.id },
+            run: { id: this.run.id, defaultOnly: false },
             joinRuns: false,
             ...filter,
         });
@@ -80,7 +80,10 @@ class IamcData extends BaseFacade {
             .agg({ run__id: 'min' })
             .loc({ columns: ['region', 'variable', 'unit', 'run__id'] });
         await this.backend.iamc.timeseries.bulkUpsert(timeseriesDf, true);
-        timeseriesDf = await this.backend.iamc.timeseries.tabulate(this.run.id, true);
+        timeseriesDf = await this.backend.iamc.timeseries.tabulate({
+            filter: { run: { id: this.run.id, defaultOnly: false } },
+            joinParameters: true,
+        });
         timeseriesDf = timeseriesDf.rename({ id: 'time_series__id' });
         // mimick pandas merge suffix option by manually renaming overlapping columns
         df.columns
@@ -96,4 +99,54 @@ class IamcData extends BaseFacade {
         });
     }
 }
-export { IamcData };
+/**
+ * Represents IAMC format data for a specific a modling platform.
+ */
+class PlatformIamcData extends BaseFacade {
+    /**
+     * Repository for managing IAMC variables.
+     */
+    variables;
+    /**
+     * Constructs a new instance of the PlatformIamcData class.
+     * @param backend The backend instance used for data retrieval.
+     */
+    constructor(backend) {
+        super(backend);
+        this.variables = new VariableRepository(this.backend);
+    }
+    /**
+     * Tabulates IAMC data with optional filtering.
+     * @param filter Optional. Filter for retrieving IAMC data.
+     * @param filter.joinRuns Optional. Whether to join runs or not, defaults to true.
+     * @returns A Promise that resolves to a dfd.DataFrame containing the tabulated data.
+     */
+    async tabulate({ joinRuns = true, ...filter } = {
+        joinRuns: true,
+    }) {
+        if (filter === undefined) {
+            filter = {};
+        }
+        // return only default runs unless a run-filter is provided
+        if (!Object.hasOwn(filter, 'run')) {
+            filter['run'] = { defaultOnly: true };
+        }
+        const joinParameters = true;
+        let df = await this.backend.iamc.datapoints.tabulate({
+            joinRuns,
+            joinParameters,
+            filter,
+        });
+        df = df.dropNa({ axis: 1 });
+        if (df.columns.includes('time_series__id')) {
+            df = df.drop({ columns: ['time_series__id'] });
+        }
+        if (df.columns.includes('unit')) {
+            // TODO report bug to danfojs: df.replace('oldValue', '', { columns: ['column_name'] }) throws: Params Error: Must specify param 'newValue' to replace with (probably newValue is cast to boolean and emty string is falsy)
+            df = df.replace('dimensionless', ' ', { columns: ['unit'] });
+            console.warn(`Unit name "dimensionless" has been replaced with ' ', this will be rejected by ixmp4.`);
+        }
+        return df;
+    }
+}
+export { RunIamcData, PlatformIamcData };

package/dist/esm/core/meta.js

@@ -6,11 +6,17 @@ import { BaseFacade } from './base';
 class MetaIndicatorRepository extends BaseFacade {
     /**
      * Tabulates meta indicators based on the provided filter.
-     * @param filter The filter to apply to the meta indicators.
+     * @param filter Optional. The filter to apply to the meta indicators.
+     * @param joinRunIndex Optional. Whether to join the run index to the tabulated data, defaults to true.
      * @returns A promise that resolves to a dfd.DataFrame containing the tabulated meta indicators.
      */
-    async tabulate(filter) {
-        return (await this.backend.meta.tabulate(filter)).drop({
+    async tabulate({ joinRunIndex = true, ...filter } = {
+        joinRunIndex: true,
+    }) {
+        if (filter === undefined) {
+            filter = {};
+        }
+        return (await this.backend.meta.tabulate(filter, joinRunIndex)).drop({
             columns: ['id', 'type'],
         });
     }

package/dist/esm/core/platform.js

@@ -3,7 +3,7 @@ import { RunRepository } from './run';
 import { ScenarioRepository } from './scenario';
 import { MetaIndicatorRepository } from './meta';
 import { ModelRepository } from './model';
-import { IamcRepository } from './iamc/repository';
+import { PlatformIamcData } from './iamc/data';
 import { RegionRepository } from './region';
 import { UnitRepository } from './unit';
 /**
@@ -35,7 +35,7 @@ class Platform {
     constructor(backend) {
         this.backend = backend;
         this.runs = new RunRepository(backend);
-        this.iamc = new IamcRepository(backend);
+        this.iamc = new PlatformIamcData(backend);
         this.scenarios = new ScenarioRepository(backend);
         this.models = new ModelRepository(backend);
         this.meta = new MetaIndicatorRepository(backend);

package/dist/esm/core/run.js

@@ -1,5 +1,5 @@
 import { BaseFacade, BaseModelFacade } from './base';
-import { IamcData } from './iamc/data';
+import { RunIamcData } from './iamc/data';
 import { RunMetaIndicatorRepository } from './meta';
 /**
  * Represents a Modeling Run.
@@ -20,7 +20,7 @@ class Run extends BaseModelFacade {
      */
     constructor(backend, model) {
         super(backend, model);
-        this.iamc = new IamcData(this.backend, this.dataModel);
+        this.iamc = new RunIamcData(this.backend, this.dataModel);
         this.meta = new RunMetaIndicatorRepository(this.backend, this.dataModel);
     }
     /**

package/dist/esm/data/base.js

@@ -1,3 +1,4 @@
+import * as dfd from 'danfojs';
 import { NotFound, UnknownApiError, createError } from '../core/exceptions';
 import { convertToSnakeCase, dfToJson, jsonToDf } from './utils';
 class BaseRepository {
@@ -5,21 +6,24 @@ class BaseRepository {
     // prefix must end with a slash
     prefix;
     enumerationMethod;
-    constructor(client, prefix, enumerationMethod) {
+    constructor(client, prefix) {
         this.client = client;
-        if (!prefix)
+        // use static porperties of extending classes via this.constructor
+        // @ts-ignore
+        this.prefix = prefix ?? this.constructor.prefix;
+        if (!this.prefix)
             throw new TypeError('Cannot instantiate repository without URL prefix.');
-        this.prefix = prefix;
-        this.enumerationMethod = enumerationMethod ?? 'GET';
+        // @ts-ignore
+        this.enumerationMethod = this.constructor.enumerationMethod ?? 'PATCH';
     }
-    async _request(url, method, params, data) {
+    async _request(url, method, params, body) {
         const config = {};
         config.url = url;
         config.method = method;
         if (params !== undefined)
             config.params = params;
-        if (data !== undefined)
-            config.data = data;
+        if (body !== undefined)
+            config.data = body;
         try {
             const res = await this.client.request(config);
             return res.data;
@@ -29,7 +33,7 @@ class BaseRepository {
         }
     }
     async _get(filter) {
-        const list = await this._list(filter);
+        const list = await this._list({ filter });
         if (list.length !== 1) {
             throw new NotFound({
                 messsage: `Expected exactly one result, got ${list.length} instead.`,
@@ -51,49 +55,72 @@ class BaseRepository {
         const url = `${this.prefix}${id}`;
         return await this._request(url, 'DELETE');
     }
-    async _enumerate(filter, table = false) {
-        let params = {};
-        let data = undefined;
-        filter = convertToSnakeCase(filter);
-        if (Object.hasOwn(filter, 'join_parameters')) {
-            params['join_parameters'] = filter['join_parameters'];
-            delete filter['join_parameters'];
+    /**
+     * Convenience method for requests to the enumeration endpoint.
+     */
+    async _requestEnumeration(params = {}, body = {}, table = false) {
+        params = convertToSnakeCase(params);
+        if (body !== undefined && Object.keys(body).length === 0) {
+            body = undefined;
         }
-        if (Object.hasOwn(filter, 'join_runs')) {
-            params['join_runs'] = filter['join_runs'];
-            delete filter['join_runs'];
-        }
-        if (Object.hasOwn(filter, 'join_run_index')) {
-            params['join_run_index'] = filter['join_run_index'];
-            delete filter['join_run_index'];
-        }
-        if (table) {
-            params['table'] = true;
+        else {
+            body = convertToSnakeCase(body);
         }
-        if (this.enumerationMethod === 'GET') {
-            for (const [key, value] of Object.entries(filter)) {
-                params[key] = value;
-            }
+        const res = await this._request(this.prefix, this.enumerationMethod, { ...params, table }, body);
+        return res;
+    }
+    /**
+     * Convenience method for paginated requests to the enumeration endpoint.
+     *
+     * @returns A list of lists of results.
+     */
+    async _handlePagination(page, table, params, body) {
+        const total = page.total;
+        const pagination = page.pagination;
+        const offset = pagination?.offset;
+        const limit = pagination?.limit;
+        if (total <= offset + limit) {
+            return [page.results];
         }
         else {
-            data = filter;
+            const newParams = { limit, offset: offset + limit };
+            params = { ...params, ...newParams };
+            const nextData = await this._requestEnumeration(params, body, table);
+            const pages = await this._handlePagination(nextData, table, params, body);
+            return [page.results, ...pages];
         }
-        if (Object.keys(params).length === 0) {
-            params = undefined;
+    }
+    async _list({ filter, params, }) {
+        const data = await this._requestEnumeration(params, filter, false);
+        const pagination = data.pagination;
+        if (pagination !== undefined) {
+            const pages = await this._handlePagination(data, false, params, filter);
+            return pages.flatMap((page) => page);
         }
-        if (data !== undefined && Object.keys(data).length === 0) {
-            data = undefined;
+        else {
+            return data;
         }
-        const res = await this._request(this.prefix, this.enumerationMethod, params, data);
-        return res;
-    }
-    async _list(filter) {
-        return await this._enumerate(filter);
     }
-    async _tabulate(filter) {
-        const jdf = await this._enumerate(filter, true);
+    async _tabulate({ filter, params, }) {
         // TODO: test what happens if we get a number that cannot be represented as float32 (or int32)
-        return jsonToDf(jdf);
+        const data = await this._requestEnumeration(params, filter, true);
+        const pagination = data.pagination;
+        if (pagination !== undefined) {
+            const pages = await this._handlePagination(data, true, params, filter);
+            // return a single dataframe if there is only one page, since dfd.concat() does not handle that properly
+            if (pages.length === 1) {
+                return jsonToDf(pages[0]);
+            }
+            else {
+                const dfList = pages
+                    .map((page) => jsonToDf(page))
+                    .filter((df) => df.length !== undefined);
+                return dfd.concat({ dfList: dfList, axis: 0 });
+            }
+        }
+        else {
+            return jsonToDf(data);
+        }
     }
     async _bulkUpsert(df, params) {
         return await this._request(`${this.prefix}bulk/`, 'POST', params, dfToJson(df));
@@ -101,9 +128,6 @@ class BaseRepository {
     async _bulkDelete(df, params) {
         return await this._request(`${this.prefix}bulk/`, 'PATCH', params, dfToJson(df));
     }
-    static requestInfo(config) {
-        return `path:${config.url} method:${config.method}; params:${JSON.stringify(config.params)}; data:${JSON.stringify(config.data)};`;
-    }
     static throwRemoteException(res, statusCode) {
         const json = res?.data;
         if (typeof json !== 'object' ||

package/dist/esm/data/docs.js

@@ -1,9 +1,6 @@
 import { BaseRepository } from './base';
 class DocsRepository extends BaseRepository {
     static enumerationMethod = 'GET';
-    constructor(client, prefix) {
-        super(client, prefix, DocsRepository.enumerationMethod);
-    }
     async get(dimensionId) {
         return await this._get({ dimension_id: dimensionId });
     }
@@ -14,7 +11,7 @@ class DocsRepository extends BaseRepository {
         }));
     }
     async list(dimensionId) {
-        return await this._list({ dimension_id: dimensionId });
+        return await this._list({ filter: { dimension_id: dimensionId } });
     }
     async delete(dimensionId) {
         await this._delete(dimensionId);

package/dist/esm/data/iamc/datapoint.js

@@ -7,26 +7,26 @@ var DataPointType;
 })(DataPointType || (DataPointType = {}));
 class DataPointRepository extends BaseRepository {
     static prefix = 'iamc/datapoints/';
-    static enumerationMethod = 'PATCH';
-    constructor(client) {
-        super(client, DataPointRepository.prefix, DataPointRepository.enumerationMethod);
-    }
-    async list({ joinParameters = false, ...filter } = {
+    async list({ joinParameters = false, filter = {}, } = {
         joinParameters: false,
+        filter: {},
     }) {
         return (await this._list({
-            joinParameters,
-            ...filter,
+            filter,
+            params: { joinParameters },
         }));
     }
-    async tabulate({ joinParameters = false, joinRuns = false, ...filter } = {
+    async tabulate({ joinParameters = false, joinRuns = false, filter = {}, } = {
         joinParameters: false,
         joinRuns: false,
+        filter: {},
     }) {
         return await this._tabulate({
-            joinParameters,
-            joinRuns,
-            ...filter,
+            filter,
+            params: {
+                joinParameters,
+                joinRuns,
+            },
         });
     }
     async bulkUpsert(df) {

package/dist/esm/data/iamc/timeseries.js

@@ -2,9 +2,6 @@ import { BaseRepository } from '../base';
 import { NotFound } from '../../core/exceptions';
 class TimeSeriesRepository extends BaseRepository {
     static prefix = 'iamc/timeseries/';
-    constructor(client) {
-        super(client, TimeSeriesRepository.prefix);
-    }
     async create(runId, parameters) {
         return (await this._post({
             run_id: runId,
@@ -33,16 +30,22 @@ class TimeSeriesRepository extends BaseRepository {
             }
         }
     }
-    async list(runIds = [], joinParameters = false) {
+    async list({ joinParameters = false, filter = {}, } = {
+        joinParameters: false,
+        filter: {},
+    }) {
         return (await this._list({
-            runIds,
-            joinParameters,
+            filter,
+            params: { joinParameters },
         }));
     }
-    async tabulate(runIds = [], joinParameters = false) {
+    async tabulate({ joinParameters = false, filter = {}, } = {
+        joinParameters: false,
+        filter: {},
+    }) {
         return await this._tabulate({
-            runIds,
-            joinParameters,
+            filter,
+            params: { joinParameters },
         });
     }
     async bulkUpsert(df, createRelated = false) {

package/dist/esm/data/iamc/variable.js

@@ -2,17 +2,16 @@ import { BaseRepository } from '../base';
 import { DocsRepository } from '../docs';
 class VariableRepository extends BaseRepository {
     static prefix = 'iamc/variables/';
-    static enumerationMethod = 'PATCH';
     docs;
     constructor(client) {
-        super(client, VariableRepository.prefix, VariableRepository.enumerationMethod);
+        super(client);
         this.docs = new DocsRepository(client, 'docs/iamc/variables/');
     }
-    async list(f = {}) {
-        return await this._list(f);
+    async list(filter = {}) {
+        return await this._list({ filter });
     }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
     async create(name) {
         return await this._post({ name });

package/dist/esm/data/meta.js

@@ -8,15 +8,11 @@ var MetaIndicatorType;
 })(MetaIndicatorType || (MetaIndicatorType = {}));
 class MetaIndicatorRepository extends BaseRepository {
     static prefix = 'meta/';
-    static enumerationMethod = 'PATCH';
-    constructor(client) {
-        super(client, MetaIndicatorRepository.prefix, MetaIndicatorRepository.enumerationMethod);
+    async list(filter = {}) {
+        return await this._list(filter);
     }
-    async list(f = {}) {
-        return await this._list(f);
-    }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}, joinRunIndex) {
+        return await this._tabulate({ filter, params: { joinRunIndex } });
     }
     async create(run__id, key, value) {
         const res = await this._post({

package/dist/esm/data/model.js

@@ -2,17 +2,16 @@ import { BaseRepository } from './base';
 import { DocsRepository } from './docs';
 class ModelRepository extends BaseRepository {
     static prefix = 'models/';
-    static enumerationMethod = 'PATCH';
     docs;
     constructor(client) {
-        super(client, ModelRepository.prefix, ModelRepository.enumerationMethod);
+        super(client);
         this.docs = new DocsRepository(client, 'docs/models/');
     }
-    async list(f = {}) {
-        return await this._list(f);
+    async list(filter = {}) {
+        return await this._list({ filter });
     }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
     async create(name) {
         const res = await this._post({ name });

package/dist/esm/data/region.js

@@ -2,18 +2,17 @@ import { BaseRepository } from './base';
 import { DocsRepository } from './docs';
 class RegionRepository extends BaseRepository {
     static prefix = 'regions/';
-    static enumerationMethod = 'PATCH';
     docs;
     constructor(client) {
-        super(client, RegionRepository.prefix, RegionRepository.enumerationMethod);
+        super(client);
         this.docs = new DocsRepository(client, 'docs/regions/');
     }
-    async list(f = {}) {
-        const Regions = await this._list(f);
+    async list(filter = {}) {
+        const Regions = await this._list({ filter });
         return Regions;
     }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
     async create(name, hierarchy) {
         const res = await this._post({

package/dist/esm/data/run.js

@@ -2,15 +2,11 @@ import { BaseRepository } from './base';
 import { NotFound } from '../core/exceptions';
 class RunRepository extends BaseRepository {
     static prefix = 'runs/';
-    static enumerationMethod = 'PATCH';
-    constructor(client) {
-        super(client, RunRepository.prefix, RunRepository.enumerationMethod);
+    async list(filter = {}) {
+        return await this._list({ filter });
     }
-    async list(f = {}) {
-        return await this._list(f);
-    }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
     async create(modelName, scenarioName) {
         const res = await this._post({
@@ -34,7 +30,7 @@ class RunRepository extends BaseRepository {
             scenario: { name: scenarioName },
             isDefault: true,
         };
-        const list = await this._list(filter);
+        const list = await this._list({ filter });
         if (list.length !== 1) {
             throw new NotFound({ message: 'Run has no default version.' });
         }

package/dist/esm/data/scenario.js

@@ -2,20 +2,19 @@ import { BaseRepository } from './base';
 import { DocsRepository } from './docs';
 class ScenarioRepository extends BaseRepository {
     static prefix = 'scenarios/';
-    static enumerationMethod = 'PATCH';
     docs;
     constructor(client) {
-        super(client, ScenarioRepository.prefix, ScenarioRepository.enumerationMethod);
+        super(client);
         this.docs = new DocsRepository(client, 'docs/scenarios/');
     }
-    async list(f = {}) {
-        return (await this._list(f));
+    async list(filter = {}) {
+        return (await this._list({ filter }));
     }
-    async tabulate(f = {}) {
-        return await this._tabulate(f);
+    async tabulate(filter = {}) {
+        return await this._tabulate({ filter });
     }
     async create(name) {
-        return (await this._post({ name: name }));
+        return (await this._post({ name }));
     }
     async get(name) {
         return (await this._get({ name }));