diff --git a/full-ifrs17-template/Database/Configure.ipynb b/full-ifrs17-template/Database/Configure.ipynb
index b332a43c..cbe56388 100644
--- a/full-ifrs17-template/Database/Configure.ipynb
+++ b/full-ifrs17-template/Database/Configure.ipynb
@@ -27,7 +27,8 @@
         {
             "cell_type": "code",
             "source": [
-                "#!import \"//ifrs17ce/dev/CalculationEngine\""
+                "#!import \"../Constants/Consts\"",
+                "\n#!eval calculationEngine"
             ]
         },
         {
diff --git a/full-ifrs17-template/Initialization/InitSystemorphBaseToMemory.ipynb b/full-ifrs17-template/Initialization/InitSystemorphBaseToMemory.ipynb
index 1dc82a4e..e910c089 100644
--- a/full-ifrs17-template/Initialization/InitSystemorphBaseToMemory.ipynb
+++ b/full-ifrs17-template/Initialization/InitSystemorphBaseToMemory.ipynb
@@ -128,25 +128,25 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<YieldCurve>(\"../Files/800.Parameters/YieldCurve.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/YieldCurve.csv\").WithType<YieldCurve>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<ExchangeRate>(\"../Files/800.Parameters/ExchangeRate.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/ExchangeRate.csv\").WithType<ExchangeRate>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<PartnerRating>(\"../Files/800.Parameters/PartnerRating.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/PartnerRating.csv\").WithType<PartnerRating>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<CreditDefaultRate>(\"../Files/800.Parameters/CreditDefaultRate.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/CreditDefaultRate.csv\").WithType<CreditDefaultRate>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
@@ -158,19 +158,19 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodesAsync(\"../Files/700.DataNodes/DataNodes_CH.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodes_CH.csv\").WithFormat(ImportFormats.DataNode).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodeStateAsync(\"../Files/700.DataNodes/DataNodeStates_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodeStates_CH_2020_12.csv\").WithFormat(ImportFormats.DataNodeState).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodeParameterAsync(\"../Files/700.DataNodes/DataNodeParameters_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodeParameters_CH_2020_12.csv\").WithFormat(ImportFormats.DataNodeParameter).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
diff --git a/full-ifrs17-template/Initialization/InitSystemorphToDatabase.ipynb b/full-ifrs17-template/Initialization/InitSystemorphToDatabase.ipynb
index 9b7b5ab5..cc45633d 100644
--- a/full-ifrs17-template/Initialization/InitSystemorphToDatabase.ipynb
+++ b/full-ifrs17-template/Initialization/InitSystemorphToDatabase.ipynb
@@ -106,25 +106,25 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<YieldCurve>(\"../Files/800.Parameters/YieldCurve.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/YieldCurve.csv\").WithType<YieldCurve>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<ExchangeRate>(\"../Files/800.Parameters/ExchangeRate.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/ExchangeRate.csv\").WithType<ExchangeRate>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<PartnerRating>(\"../Files/800.Parameters/PartnerRating.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/PartnerRating.csv\").WithType<PartnerRating>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDimensionsAsync<CreditDefaultRate>(\"../Files/800.Parameters/CreditDefaultRate.csv\")"
+                "await Import.FromFile(\"../Files/800.Parameters/CreditDefaultRate.csv\").WithType<CreditDefaultRate>().SnapshotMode().WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
@@ -136,19 +136,19 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodesAsync(\"../Files/700.DataNodes/DataNodes_CH.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodes_CH.csv\").WithFormat(ImportFormats.DataNode).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodeStateAsync(\"../Files/700.DataNodes/DataNodeStates_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodeStates_CH_2020_12.csv\").WithFormat(ImportFormats.DataNodeState).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadDataNodeParameterAsync(\"../Files/700.DataNodes/DataNodeParameters_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/700.DataNodes/DataNodeParameters_CH_2020_12.csv\").WithFormat(ImportFormats.DataNodeParameter).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
@@ -160,31 +160,31 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadOpeningAsync(\"../Files/900.TransactionalData/Openings_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Openings_CH_2020_12.csv\").WithFormat(ImportFormats.Opening).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadCashflowsAsync(\"../Files/900.TransactionalData/NominalCashflows_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/NominalCashflows_CH_2020_12.csv\").WithFormat(ImportFormats.Cashflow).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadActualAsync(\"../Files/900.TransactionalData/Actuals_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Actuals_CH_2020_12.csv\").WithFormat(ImportFormats.Actual).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadCashflowsAsync(\"../Files/900.TransactionalData/NominalCashflows_CH_2021_3.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/NominalCashflows_CH_2021_3.csv\").WithFormat(ImportFormats.Cashflow).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadActualAsync(\"../Files/900.TransactionalData/Actuals_CH_2021_3.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Actuals_CH_2021_3.csv\").WithFormat(ImportFormats.Actual).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
diff --git a/full-ifrs17-template/Initialization/InitSystemorphToMemory.ipynb b/full-ifrs17-template/Initialization/InitSystemorphToMemory.ipynb
index c9eb277e..1685c887 100644
--- a/full-ifrs17-template/Initialization/InitSystemorphToMemory.ipynb
+++ b/full-ifrs17-template/Initialization/InitSystemorphToMemory.ipynb
@@ -52,31 +52,31 @@
         {
             "cell_type": "code",
             "source": [
-                "await UploadOpeningAsync(\"../Files/900.TransactionalData/Openings_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Openings_CH_2020_12.csv\").WithFormat(ImportFormats.Opening).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadCashflowsAsync(\"../Files/900.TransactionalData/NominalCashflows_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/NominalCashflows_CH_2020_12.csv\").WithFormat(ImportFormats.Cashflow).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadActualAsync(\"../Files/900.TransactionalData/Actuals_CH_2020_12.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Actuals_CH_2020_12.csv\").WithFormat(ImportFormats.Actual).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadCashflowsAsync(\"../Files/900.TransactionalData/NominalCashflows_CH_2021_3.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/NominalCashflows_CH_2021_3.csv\").WithFormat(ImportFormats.Cashflow).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
             "cell_type": "code",
             "source": [
-                "await UploadActualAsync(\"../Files/900.TransactionalData/Actuals_CH_2021_3.csv\")"
+                "await Import.FromFile(\"../Files/900.TransactionalData/Actuals_CH_2021_3.csv\").WithFormat(ImportFormats.Actual).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
diff --git a/full-ifrs17-template/Test/MapTemplateAndImportTest.ipynb b/full-ifrs17-template/Test/MapTemplateAndImportTest.ipynb
index e0b58e97..69f8137a 100644
--- a/full-ifrs17-template/Test/MapTemplateAndImportTest.ipynb
+++ b/full-ifrs17-template/Test/MapTemplateAndImportTest.ipynb
@@ -443,8 +443,7 @@
             "source": [
                 "public async Task CheckErrors(string inputFileName, List<string> errorBms)",
                 "\n{",
-                "\n   var partitionId = new Guid();",
-                "\n   var log = await UploadDataNodeParameterToWorkspaceAsync(inputFileName, partitionId);",
+                "\n   var log = await Import.FromFile(inputFileName).WithFormat(ImportFormats.DataNodeParameter).WithTarget(Workspace).ExecuteAsync();",
                 "\n   Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n   errorBms.Intersect(log.Errors.Select(x => x.ToString().Substring(0,x.ToString().Length-2).Substring(40)).ToArray()).Count().Should().Be(errorBms.Count());",
                 "\n}"
diff --git a/full-ifrs17-template/Test/SpecificationsImportCashflows.ipynb b/full-ifrs17-template/Test/SpecificationsImportCashflows.ipynb
index 12b9fc30..d75b5206 100644
--- a/full-ifrs17-template/Test/SpecificationsImportCashflows.ipynb
+++ b/full-ifrs17-template/Test/SpecificationsImportCashflows.ipynb
@@ -116,7 +116,7 @@
             "cell_type": "code",
             "source": [
                 "var groupOfContract = \"GricComplex\";",
-                "\nawait UploadCashflowsAsync(\"Data/CashflowComplex.csv\")"
+                "\nawait Import.FromFile(\"Data/CashflowComplex.csv\").WithFormat(ImportFormats.Cashflow).WithTarget(DataSource).ExecuteAsync()"
             ]
         },
         {
diff --git a/ifrs17/Constants/Consts.ipynb b/ifrs17/Constants/Consts.ipynb
index 8c67e92e..d5dafed5 100644
--- a/ifrs17/Constants/Consts.ipynb
+++ b/ifrs17/Constants/Consts.ipynb
@@ -138,7 +138,9 @@
                 "public static class ImportFormats{",
                 "\n    public const string Cashflow = nameof(Cashflow);",
                 "\n    public const string Actual = nameof(Actual);",
+                "\n    public const string DataNode = nameof(DataNode);",
                 "\n    public const string DataNodeParameter = nameof(DataNodeParameter);",
+                "\n    public const string DataNodeState = nameof(DataNodeState);",
                 "\n    public const string SimpleValue = nameof(SimpleValue);",
                 "\n    public const string Opening = nameof(Opening);",
                 "\n    public const string AocConfiguration = nameof(AocConfiguration);",
diff --git a/ifrs17/Import/Importers.ipynb b/ifrs17/Import/Importers.ipynb
index 6be43097..8a499aa5 100644
--- a/ifrs17/Import/Importers.ipynb
+++ b/ifrs17/Import/Importers.ipynb
@@ -266,16 +266,14 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task DataNodeFactoryAsync(string file, string tab, ImportArgs args)",
+                "public async Task DataNodeFactoryAsync(IDataSet dataSet, string tableName, ImportArgs args)",
                 "\n{",
                 "\n    var partition = (await DataSource.Query<PartitionByReportingNode>().Where(p => p.ReportingNode == args.ReportingNode && p.Scenario == null).ToArrayAsync()).SingleOrDefault();",
                 "\n    if(partition == null) { ApplicationMessage.Log(Error.ParsedPartitionNotFound); return; }",
                 "\n",
-                "\n    var extension = System.IO.Path.GetExtension(file);",
-                "\n    var stream = await Project.FileStorage.ReadAsync(file);",
-                "\n    var target = (await DataSetReader.ReadFromStream(stream).WithContentType(extension).ExecuteAsync()).DataSet.Tables[tab];",
+                "\n    var table = dataSet.Tables[tableName];",
                 "\n",
-                "\n    var dataNodesImported = target.Rows.Select(x => x.Field<string>(nameof(RawVariable.DataNode))).ToHashSet();",
+                "\n    var dataNodesImported = table.Rows.Select(x => x.Field<string>(nameof(RawVariable.DataNode))).ToHashSet();",
                 "\n    var dataNodesDefined = await DataSource.Query<GroupOfContract>().Where(x => dataNodesImported.Contains(x.SystemName)).ToArrayAsync();",
                 "\n    var dataNodeStatesDefined = await DataSource.Query<DataNodeState>().Select(x => x.DataNode).ToArrayAsync();",
                 "\n    var dataNodeParametersDefined = await DataSource.Query<SingleDataNodeParameter>().Select(x => x.DataNode).ToArrayAsync();  ",
@@ -304,24 +302,7 @@
         {
             "cell_type": "markdown",
             "source": [
-                "## Parse and Upload: Dimensions"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "source": [
-                "public async Task<ActivityLog> UploadDimensionsAsync<T> (string fileName) where T: class ",
-                "\n{",
-                "\n    await CleanDatabaseAsync<T>();",
-                "\n    var importLog = await Import.FromFile(fileName).WithType<T>().WithTarget(DataSource).ExecuteAsync();",
-                "\n    return importLog;",
-                "\n}"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "source": [
-                "### Analysis of Change Configuration"
+                "## Analysis of Change Configuration"
             ]
         },
         {
@@ -430,11 +411,9 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ImportArgs> GetArgsFromMainAsync<IPartition>(string file)",
+                "public async Task<ImportArgs> GetArgsFromMainAsync<IPartition>(IDataSet dataSet)",
                 "\n{",
-                "\n    var extension = System.IO.Path.GetExtension(file);",
-                "\n    var stream = await Project.FileStorage.ReadAsync(file);",
-                "\n    var mainTab = (await DataSetReader.ReadFromStream(stream).WithContentType(extension).ExecuteAsync()).DataSet.Tables[Main];",
+                "\n    var mainTab = dataSet.Tables[Main];",
                 "\n    ",
                 "\n    if(mainTab == null) ApplicationMessage.Log(Error.NoMainTab);",
                 "\n    if(mainTab.Rows.Count() == 0) ApplicationMessage.Log(Error.IncompleteMainTab);",
@@ -471,7 +450,7 @@
         {
             "cell_type": "markdown",
             "source": [
-                "### Parse and Upload: Data Nodes"
+                "## Parse and Upload: Data Nodes"
             ]
         },
         {
@@ -483,7 +462,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodesToWorkspaceAsync(string fileName)",
+                "public async Task<ActivityLog> UploadDataNodesToWorkspaceAsync(IDataSet dataSet)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -493,7 +472,7 @@
                 "\n                               .DisableInitialization<DataNodeParameter>());",
                 "\n    ",
                 "\n    Activity.Start();",
-                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNode>(fileName);",
+                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNode>(dataSet);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
                 "\n    var storage = new ParsingStorage(args, DataSource, Workspace);",
@@ -501,7 +480,7 @@
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n       ",
                 "\n    var errors = new List<string>();",
-                "\n    var importLogPortfolios = await Import.FromFile(fileName)",
+                "\n    var importLogPortfolios = await Import.FromDataSet(dataSet)",
                 "\n        .WithType<InsurancePortfolio>((dataset, datarow) => new InsurancePortfolio {",
                 "\n                                                                                        SystemName = datarow.Field<string>(nameof(DataNode.SystemName)),",
                 "\n                                                                                        DisplayName = datarow.Field<string>(nameof(DataNode.DisplayName)),",
@@ -526,7 +505,7 @@
                 "\n        .ExecuteAsync();",
                 "\n    ",
                 "\n    var portfolios = await Workspace.Query<Portfolio>().ToDictionaryAsync(x => x.SystemName);",
-                "\n    var importLogGroupOfContracts = await Import.FromFile(fileName)",
+                "\n    var importLogGroupOfContracts = await Import.FromDataSet(dataSet)",
                 "\n        .WithType<GroupOfInsuranceContract>((dataset, datarow) => {",
                 "\n                                                                    var gicSystemName = datarow.Field<string>(nameof(DataNode.SystemName));",
                 "\n                                                                    var pf = datarow.Field<string>(nameof(InsurancePortfolio));",
@@ -586,16 +565,15 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodesAsync(string fileName)",
-                "\n{",
-                "\n    var log = await UploadDataNodesToWorkspaceAsync(fileName);",
+                "Import.DefineFormat(ImportFormats.DataNode, async (options, dataSet) => {",
+                "\n    var log = await UploadDataNodesToWorkspaceAsync(dataSet);",
                 "\n    var partition = (Guid)Workspace.Partition.GetCurrent(nameof(PartitionByReportingNode));",
                 "\n    await CommitToDatabase<InsurancePortfolio>(partition);",
                 "\n    await CommitToDatabase<ReinsurancePortfolio>(partition);",
                 "\n    await CommitToDatabase<GroupOfInsuranceContract>(partition);",
                 "\n    await CommitToDatabase<GroupOfReinsuranceContract>(partition);",
                 "\n    return log;",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -628,7 +606,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodeStateToWorkspaceAsync(string fileName)",
+                "public async Task<ActivityLog> UploadDataNodeStateToWorkspaceAsync(IDataSet dataSet)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -639,14 +617,14 @@
                 "\n    await Workspace.DeleteAsync<DataNodeState>(await Workspace.Query<DataNodeState>().ToArrayAsync() );",
                 "\n    ",
                 "\n    Activity.Start();",
-                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName);",
+                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
                 "\n    var storage = new ParsingStorage(args, DataSource, Workspace);",
                 "\n    await storage.InitializeAsync();",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n",
-                "\n    var importLog = await Import.FromFile(fileName).WithType<DataNodeState>(",
+                "\n    var importLog = await Import.FromDataSet(dataSet).WithType<DataNodeState>(",
                 "\n        (dataset, datarow) => new DataNodeState {",
                 "\n            DataNode = datarow.Field<string>(nameof(DataNodeState.DataNode)),",
                 "\n            State = (State)Enum.Parse(typeof(State), datarow.Field<string>(nameof(DataNodeState.State))),",
@@ -664,12 +642,11 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodeStateAsync(string fileName)",
-                "\n{",
-                "\n    var log = await UploadDataNodeStateToWorkspaceAsync(fileName);",
+                "Import.DefineFormat(ImportFormats.DataNodeState, async (options, dataSet) => {",
+                "\n    var log = await UploadDataNodeStateToWorkspaceAsync(dataSet);",
                 "\n    await CommitToDatabase<DataNodeState>((Guid)Workspace.Partition.GetCurrent(nameof(PartitionByReportingNode)), snapshot: false);    ",
                 "\n    return log;",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -681,7 +658,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodeParameterToWorkspaceAsync(string fileName, Guid targetPartitionByReportingNodeId)",
+                "public async Task<ActivityLog> UploadDataNodeParameterToWorkspaceAsync(IDataSet dataSet, Guid targetPartitionByReportingNodeId)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -692,7 +669,7 @@
                 "\n    await Workspace.DeleteAsync<DataNodeParameter>(await Workspace.Query<DataNodeParameter>().ToArrayAsync() );",
                 "\n    ",
                 "\n    Activity.Start();",
-                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName) with {ImportFormat = ImportFormats.DataNodeParameter};",
+                "\n    var args = await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet) with {ImportFormat = ImportFormats.DataNodeParameter};",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n",
                 "\n    var storage = new ParsingStorage(args, DataSource, Workspace);",
@@ -702,7 +679,7 @@
                 "\n    var singleDataNode = new List<string>();",
                 "\n    var interDataNode = new List<(string,string)>();",
                 "\n    ",
-                "\n    var importLog = await Import.FromFile(fileName)",
+                "\n    var importLog = await Import.FromDataSet(dataSet)",
                 "\n                                .WithType<SingleDataNodeParameter>( (dataset, datarow) => {",
                 "\n",
                 "\n                                    //read and validate DataNodes",
@@ -769,16 +746,15 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadDataNodeParameterAsync(string fileName)",
-                "\n{",
+                "Import.DefineFormat(ImportFormats.DataNodeParameter, async (options, dataSet) => {",
                 "\n    Guid partitionId = new Guid();",
-                "\n    var log = await UploadDataNodeParameterToWorkspaceAsync(fileName, partitionId);",
+                "\n    var log = await UploadDataNodeParameterToWorkspaceAsync(dataSet, partitionId);",
                 "\n      ",
                 "\n    await CommitToDatabase<SingleDataNodeParameter>(partitionId, snapshot: false);",
                 "\n    await CommitToDatabase<InterDataNodeParameter>(partitionId, snapshot: false);    ",
                 "\n    ",
                 "\n    return log;",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -813,7 +789,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> ParseCashflowsToWorkspaceAsync(string fileName, ImportArgs args)",
+                "public async Task<ActivityLog> ParseCashflowsToWorkspaceAsync(IDataSet dataSet, ImportArgs args)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -825,7 +801,7 @@
                 "\n    await parsingStorage.InitializeAsync();",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
-                "\n    var importLog = await Import.FromFile(fileName)",
+                "\n    var importLog = await Import.FromDataSet(dataSet)",
                 "\n        .WithType<RawVariable> ( (dataset, datarow) => {",
                 "\n            var aocType = datarow.Field<string>(nameof(RawVariable.AocType));",
                 "\n            var novelty = datarow.Field<string>(nameof(RawVariable.Novelty));",
@@ -881,14 +857,13 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadCashflowsAsync(string fileName)",
-                "\n{",
+                "Import.DefineFormat(ImportFormats.Cashflow, async (options, dataSet) => {",
                 "\n    Activity.Start();",
-                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName)) with {ImportFormat = ImportFormats.Cashflow};",
-                "\n    await DataNodeFactoryAsync(fileName, ImportFormats.Cashflow, args);",
+                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet)) with {ImportFormat = ImportFormats.Cashflow};",
+                "\n    await DataNodeFactoryAsync(dataSet, ImportFormats.Cashflow, args);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
-                "\n    var parsingLog = await ParseCashflowsToWorkspaceAsync(fileName, args);",
+                "\n    var parsingLog = await ParseCashflowsToWorkspaceAsync(dataSet, args);",
                 "\n    if(parsingLog.Errors.Any()) return Activity.Finish().Merge(parsingLog);",
                 "\n    ",
                 "\n    var storage = new ImportStorage(args, DataSource, Workspace);",
@@ -910,7 +885,7 @@
                 "\n                                        filter : x => storage.DataNodesByImportScope[ImportScope.Primary].Contains(x.DataNode));",
                 "\n",
                 "\n    return Activity.Finish().Merge(parsingLog); ",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -922,7 +897,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> ParseActualsToWorkspaceAsync(string fileName, ImportArgs args)",
+                "public async Task<ActivityLog> ParseActualsToWorkspaceAsync(IDataSet dataSet, ImportArgs args)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -934,7 +909,7 @@
                 "\n    await parsingStorage.InitializeAsync();",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n",
-                "\n    var importLog = await Import.FromFile(fileName)",
+                "\n    var importLog = await Import.FromDataSet(dataSet)",
                 "\n        .WithType<IfrsVariable> ( (dataset, datarow) => {",
                 "\n            var dataNode = datarow.Field<string>(nameof(DataNode));",
                 "\n            if(!parsingStorage.DataNodeDataBySystemName.TryGetValue(dataNode, out var dataNodeData)) {",
@@ -985,14 +960,13 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadActualAsync(string fileName)",
-                "\n{",
+                "Import.DefineFormat(ImportFormats.Actual, async (options, dataSet) => {",
                 "\n    Activity.Start();",
-                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName)) with {ImportFormat = ImportFormats.Actual};",
-                "\n    await DataNodeFactoryAsync(fileName, ImportFormats.Actual, args);",
+                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet)) with {ImportFormat = ImportFormats.Actual};",
+                "\n    await DataNodeFactoryAsync(dataSet, ImportFormats.Actual, args);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n",
-                "\n    var parsingLog = await ParseActualsToWorkspaceAsync(fileName, args);",
+                "\n    var parsingLog = await ParseActualsToWorkspaceAsync(dataSet, args);",
                 "\n    if(parsingLog.Errors.Any()) return Activity.Finish().Merge(parsingLog);",
                 "\n",
                 "\n    var storage = new ImportStorage(args, DataSource, Workspace);",
@@ -1011,7 +985,7 @@
                 "\n                                                       storage.DataNodesByImportScope[ImportScope.Primary].Contains(x.DataNode));",
                 "\n",
                 "\n    return Activity.Finish().Merge(parsingLog);",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -1029,7 +1003,7 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> ParseSimpleValueToWorkspaceAsync(string fileName, ImportArgs args, Guid targetPartitionByReportingNodeAndPeriodId)",
+                "public async Task<ActivityLog> ParseSimpleValueToWorkspaceAsync(IDataSet dataSet, ImportArgs args, Guid targetPartitionByReportingNodeAndPeriodId)",
                 "\n{",
                 "\n    Workspace.Reset(x => x.ResetInitializationRules().ResetCurrentPartitions());",
                 "\n    Workspace.Initialize(x => x.FromSource(DataSource)",
@@ -1042,7 +1016,7 @@
                 "\n    await parsingStorage.InitializeAsync();",
                 "\n    if(Activity.HasErrors()) return Activity.Finish(); ",
                 "\n",
-                "\n    var importLog = await Import.FromFile(fileName)",
+                "\n    var importLog = await Import.FromDataSet(dataSet)",
                 "\n        .WithType<IfrsVariable> ( (dataset, datarow) => {",
                 "\n            var dataNode = parsingStorage.ValidateDataNode(datarow.Field<string>(nameof(DataNode)));",
                 "\n            var amountType = parsingStorage.ValidateAmountType(datarow.Field<string>(nameof(IfrsVariable.AmountType)));",
@@ -1101,15 +1075,14 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadSimpleValueAsync(string fileName)",
-                "\n{",
+                "Import.DefineFormat(ImportFormats.SimpleValue, async (options, dataSet) => {",
                 "\n    Activity.Start();",
-                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName)) with {ImportFormat = ImportFormats.SimpleValue};",
-                "\n    await DataNodeFactoryAsync(fileName, ImportFormats.SimpleValue, args);",
+                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet)) with {ImportFormat = ImportFormats.SimpleValue};",
+                "\n    await DataNodeFactoryAsync(dataSet, ImportFormats.SimpleValue, args);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
                 "\n    Guid partitionId = new Guid();",
-                "\n    var parsingLog = await ParseSimpleValueToWorkspaceAsync(fileName, args, partitionId);",
+                "\n    var parsingLog = await ParseSimpleValueToWorkspaceAsync(dataSet, args, partitionId);",
                 "\n    if(parsingLog.Errors.Any()) return Activity.Finish().Merge(parsingLog);",
                 "\n    ",
                 "\n    Workspace.Query<IfrsVariable>().Select(v => new {v.DataNode, v.AccidentYear}).Distinct();",
@@ -1119,7 +1092,7 @@
                 "\n                                         filter : x => Workspace.Query<IfrsVariable>().Select(v => v.DataNode).Distinct().Contains(x.DataNode));",
                 "\n    ",
                 "\n    return Activity.Finish().Merge(parsingLog);",
-                "\n}"
+                "\n});"
             ]
         },
         {
@@ -1131,15 +1104,14 @@
         {
             "cell_type": "code",
             "source": [
-                "public async Task<ActivityLog> UploadOpeningAsync(string fileName)",
-                "\n{",
+                "Import.DefineFormat(ImportFormats.Opening, async (options, dataSet) => {",
                 "\n    Activity.Start();",
-                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(fileName)) with {ImportFormat = ImportFormats.Opening};",
-                "\n    await DataNodeFactoryAsync(fileName, ImportFormats.Opening, args);",
+                "\n    var args = (await GetArgsFromMainAsync<PartitionByReportingNodeAndPeriod>(dataSet)) with {ImportFormat = ImportFormats.Opening};",
+                "\n    await DataNodeFactoryAsync(dataSet, ImportFormats.Opening, args);",
                 "\n    if(Activity.HasErrors()) return Activity.Finish();",
                 "\n    ",
                 "\n    Guid partitionId = new Guid();",
-                "\n    var parsingLog = await ParseSimpleValueToWorkspaceAsync(fileName, args, partitionId);",
+                "\n    var parsingLog = await ParseSimpleValueToWorkspaceAsync(dataSet, args, partitionId);",
                 "\n    if(parsingLog.Errors.Any()) return Activity.Finish().Merge(parsingLog);",
                 "\n    ",
                 "\n    var storage = new ImportStorage(args, DataSource, Workspace);",
@@ -1158,7 +1130,7 @@
                 "\n                                                       storage.DataNodesByImportScope[ImportScope.Primary].Contains(x.DataNode ));",
                 "\n",
                 "\n    return Activity.Finish().Merge(parsingLog);",
-                "\n}"
+                "\n});"
             ]
         },
         {